From 5cda687b238a95844d49a032d7823814aeb945b9 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Mon, 20 May 2019 21:28:41 +0100
Subject: [PATCH 01/97] Set Visual Studio flags in CMake

---
 CMakeLists.txt | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index fb95b6a..20c151c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -7,7 +7,12 @@ cmake_minimum_required(VERSION 3.12)
 project(libstdaudio)
 
 set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
+
+if (MSVC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4 /WX")
+else ()
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
+endif ()
 
 if (APPLE)
     set(CMAKE_EXE_LINKER_FLAGS "-framework CoreAudio")

From 88aa731ffa09c6e401a79de090e470478d4902ae Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Mon, 20 May 2019 21:34:02 +0100
Subject: [PATCH 02/97] Modify __null_backend to compile on Windows

---
 include/audio_backend/__null_backend.h | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/include/audio_backend/__null_backend.h b/include/audio_backend/__null_backend.h
index 15b7651..8d5f976 100644
--- a/include/audio_backend/__null_backend.h
+++ b/include/audio_backend/__null_backend.h
@@ -7,6 +7,7 @@
 
 #include <string_view>
 #include <chrono>
+#include <cassert>
 
 _LIBSTDAUDIO_NAMESPACE_BEGIN
 
@@ -40,7 +41,7 @@ class audio_device {
     return 0;
   }
 
-  using sample_rate_t = unsigned;
+  using sample_rate_t = int;
 
   sample_rate_t get_sample_rate() const noexcept {
     return {};
@@ -54,7 +55,7 @@ class audio_device {
     return false;
   }
 
-  using buffer_size_t  = unsigned;
+  using buffer_size_t  = int;
 
   buffer_size_t get_buffer_size_frames() const noexcept {
     return {};
@@ -64,7 +65,7 @@ class audio_device {
     return {};
   }
 
-  bool set_buffer_size_frames(buffer_size_t new_buffer_size) {
+  bool set_buffer_size_frames(buffer_size_t) {
     return false;
   }
 
@@ -102,6 +103,11 @@ class audio_device {
     assert(false);
   }
 
+  template <typename _CallbackType>
+  void connect(_CallbackType) {
+    assert(false);
+  }
+
   constexpr bool has_unprocessed_io() const noexcept {
     return false;
   }
@@ -124,6 +130,8 @@ class audio_device_list
 public:
   auto begin() -> iterator { return {}; }
   auto end() -> iterator { return {}; }
+  auto begin() const -> iterator { return {}; }
+  auto end() const -> iterator { return {}; }
   auto empty() -> bool { return true; }
 };
 
@@ -143,4 +151,4 @@ audio_device_list get_audio_output_device_list() {
   return {};
 }
 
-_LIBSTDAUDIO_NAMESPACE_END
\ No newline at end of file
+_LIBSTDAUDIO_NAMESPACE_END

From 4b86b3eae57e00bf3eb054cfcf7be0490f7e8b40 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Mon, 20 May 2019 21:35:44 +0100
Subject: [PATCH 03/97] Modify __audio_buffer to compile on Windows

---
 include/__audio_buffer.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/include/__audio_buffer.h b/include/__audio_buffer.h
index 6629d07..380a9aa 100644
--- a/include/__audio_buffer.h
+++ b/include/__audio_buffer.h
@@ -5,6 +5,8 @@
 
 #pragma once
 
+#include <cassert>
+
 #include <chrono>
 
 _LIBSTDAUDIO_NAMESPACE_BEGIN

From add97fd38076194ffe2ad7ebe7abb1ee29d27850 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Mon, 20 May 2019 21:38:27 +0100
Subject: [PATCH 04/97] Specify _USE_MATH_DEFINES on Windows

---
 examples/melody.cpp    | 6 +++++-
 examples/sine_wave.cpp | 6 +++++-
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/examples/melody.cpp b/examples/melody.cpp
index 440260c..6f3c4e9 100644
--- a/examples/melody.cpp
+++ b/examples/melody.cpp
@@ -3,6 +3,10 @@
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
 
+#ifdef WIN32
+#define _USE_MATH_DEFINES
+#endif
+
 #include <cmath>
 #include <array>
 #include <thread>
@@ -95,4 +99,4 @@ int main() {
   while (!stop.load()) {
     std::this_thread::sleep_for(std::chrono::milliseconds(50));
   }
-}
\ No newline at end of file
+}
diff --git a/examples/sine_wave.cpp b/examples/sine_wave.cpp
index 92a4682..6c8e083 100644
--- a/examples/sine_wave.cpp
+++ b/examples/sine_wave.cpp
@@ -3,6 +3,10 @@
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
 
+#ifdef WIN32
+#define _USE_MATH_DEFINES
+#endif
+
 #include <cmath>
 #include <thread>
 #include <audio>
@@ -37,4 +41,4 @@ int main() {
 
   device->start();
   std::this_thread::sleep_for(std::chrono::seconds(5));
-}
\ No newline at end of file
+}

From dc8dfbdd7f30b6d6d16a6e8b662957741e62372f Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Mon, 20 May 2019 21:39:50 +0100
Subject: [PATCH 05/97] Add <atomic> header that was previously only included
 transitively

---
 examples/melody.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/examples/melody.cpp b/examples/melody.cpp
index 6f3c4e9..e0782af 100644
--- a/examples/melody.cpp
+++ b/examples/melody.cpp
@@ -10,6 +10,7 @@
 #include <cmath>
 #include <array>
 #include <thread>
+#include <atomic>
 #include <audio>
 
 // This example app plays a short melody using a simple square wave synthesiser.
@@ -34,7 +35,7 @@ struct synthesiser {
   float get_next_sample() {
     assert (_sample_rate > 0);
 
-    _ms_counter += 1000. / _sample_rate;
+    _ms_counter += 1000.0f / _sample_rate;
     if (_ms_counter >= _note_duration_ms) {
       _ms_counter = 0;
       if (++_current_note_index < notes.size()) {

From 7f471530f612891668fb371de3104b4af9d4d139 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Mon, 20 May 2019 21:41:15 +0100
Subject: [PATCH 06/97] Cast M_PI to float to avoid narrowing conversion
 warning

---
 examples/sine_wave.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/sine_wave.cpp b/examples/sine_wave.cpp
index 6c8e083..0878df3 100644
--- a/examples/sine_wave.cpp
+++ b/examples/sine_wave.cpp
@@ -32,7 +32,7 @@ int main() {
 
     for (int frame = 0; frame < out.size_frames(); ++frame) {
       float next_sample = std::sin(phase);
-      phase = std::fmod(phase + delta, 2.0f * M_PI);
+      phase = std::fmod(phase + delta, 2.0f * float(M_PI));
 
       for (int channel = 0; channel < out.size_channels(); ++channel)
         out(frame, channel) = 0.2f * next_sample;

From ad4398603ff9a1038f889b4a4f4d124c08aba0c4 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Mon, 20 May 2019 21:43:28 +0100
Subject: [PATCH 07/97] Removed unused parameter

All samples now compile without error on Windows
---
 examples/sine_wave.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/sine_wave.cpp b/examples/sine_wave.cpp
index 0878df3..24d7ad6 100644
--- a/examples/sine_wave.cpp
+++ b/examples/sine_wave.cpp
@@ -24,7 +24,7 @@ int main() {
   float delta = 2.0f * frequency_hz * float(M_PI / device->get_sample_rate());
   float phase = 0;
 
-  device->connect([=](audio_device& device, audio_device_io<float>& io) mutable noexcept {
+  device->connect([=](audio_device&, audio_device_io<float>& io) mutable noexcept {
     if (!io.output_buffer.has_value())
       return;
 

From be138d2c8d74d617c7cd8563818fe7bda81840b8 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Mon, 20 May 2019 21:45:20 +0100
Subject: [PATCH 08/97] Use const where possible

---
 examples/level_meter.cpp   | 4 ++--
 examples/melody.cpp        | 4 ++--
 examples/sine_wave.cpp     | 6 +++---
 test/audio_device_test.cpp | 4 ++--
 4 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/examples/level_meter.cpp b/examples/level_meter.cpp
index 1fc0cae..22d1180 100644
--- a/examples/level_meter.cpp
+++ b/examples/level_meter.cpp
@@ -32,7 +32,7 @@ int main() {
 
     for (int frame = 0; frame < in.size_frames(); ++frame) {
       for (int channel = 0; channel < in.size_channels(); ++channel) {
-        float abs_value = std::abs(in(frame, channel));
+        const float abs_value = std::abs(in(frame, channel));
 
         if (abs_value > max_abs_value)
           max_abs_value.store(abs_value);
@@ -45,4 +45,4 @@ int main() {
     std::this_thread::sleep_for(std::chrono::milliseconds(250));
     std::cout << gain_to_db(max_abs_value.exchange(0)) << " dB\n";
   }
-}
\ No newline at end of file
+}
diff --git a/examples/melody.cpp b/examples/melody.cpp
index e0782af..4783c17 100644
--- a/examples/melody.cpp
+++ b/examples/melody.cpp
@@ -47,7 +47,7 @@ struct synthesiser {
       }
     }
 
-    auto next_sample = std::copysign(0.1f, std::sin(_phase));
+    const auto next_sample = std::copysign(0.1f, std::sin(_phase));
     _phase = std::fmod(_phase + _delta, 2.0f * float(M_PI));
     return next_sample;
   }
@@ -59,7 +59,7 @@ struct synthesiser {
 
 private:
   void update() noexcept {
-    float frequency_hz = note_to_frequency_hz(notes.at(_current_note_index));
+    const float frequency_hz = note_to_frequency_hz(notes.at(_current_note_index));
     _delta = 2.0f * frequency_hz * static_cast<float>(M_PI / _sample_rate);
   }
 
diff --git a/examples/sine_wave.cpp b/examples/sine_wave.cpp
index 24d7ad6..db49877 100644
--- a/examples/sine_wave.cpp
+++ b/examples/sine_wave.cpp
@@ -20,8 +20,8 @@ int main() {
   if (!device)
     return 1;
 
-  float frequency_hz = 440.0f;
-  float delta = 2.0f * frequency_hz * float(M_PI / device->get_sample_rate());
+  const float frequency_hz = 440.0f;
+  const float delta = 2.0f * frequency_hz * float(M_PI / device->get_sample_rate());
   float phase = 0;
 
   device->connect([=](audio_device&, audio_device_io<float>& io) mutable noexcept {
@@ -31,7 +31,7 @@ int main() {
     auto& out = *io.output_buffer;
 
     for (int frame = 0; frame < out.size_frames(); ++frame) {
-      float next_sample = std::sin(phase);
+      const float next_sample = std::sin(phase);
       phase = std::fmod(phase + delta, 2.0f * float(M_PI));
 
       for (int channel = 0; channel < out.size_channels(); ++channel)
diff --git a/test/audio_device_test.cpp b/test/audio_device_test.cpp
index 38c771b..666a907 100644
--- a/test/audio_device_test.cpp
+++ b/test/audio_device_test.cpp
@@ -50,7 +50,7 @@ TEST_CASE("All output devices have unique IDs")
 
 TEST_CASE("If there are any input devices, there must be a default input device")
 {
-  auto default_device = get_default_audio_input_device();
+  const auto default_device = get_default_audio_input_device();
   auto devices = get_audio_input_device_list();
   if (devices.empty()) {
     CHECK_FALSE(default_device.has_value());
@@ -62,7 +62,7 @@ TEST_CASE("If there are any input devices, there must be a default input device"
 
 TEST_CASE("If there are any output devices, there must be a default output device")
 {
-  auto default_device = get_default_audio_output_device();
+  const auto default_device = get_default_audio_output_device();
   auto devices = get_audio_output_device_list();
   if (devices.empty()) {
     CHECK_FALSE(default_device.has_value());

From 7202ebb9dad64c46e1d153a98abddc6ff9e2d470 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Mon, 20 May 2019 21:47:30 +0100
Subject: [PATCH 09/97] Add __windows_backend.h

This is a copy of __null_backend.h initially
---
 include/audio                             |   2 +
 include/audio_backend/__windows_backend.h | 160 ++++++++++++++++++++++
 2 files changed, 162 insertions(+)
 create mode 100644 include/audio_backend/__windows_backend.h

diff --git a/include/audio b/include/audio
index 7e0f98c..135f379 100644
--- a/include/audio
+++ b/include/audio
@@ -21,6 +21,8 @@ using namespace TCB_SPAN_NAMESPACE_NAME;
 
 #ifdef __APPLE__
   #include <audio_backend/__coreaudio_backend.h>
+#elif defined _WIN32
+  #include <audio_backend/__windows_backend.h>
 #else
   #include <audio_backend/__null_backend.h>
 #endif // __APPLE__
diff --git a/include/audio_backend/__windows_backend.h b/include/audio_backend/__windows_backend.h
new file mode 100644
index 0000000..9331f15
--- /dev/null
+++ b/include/audio_backend/__windows_backend.h
@@ -0,0 +1,160 @@
+// libstdaudio
+// Copyright (c) 2018 - Timur Doumler
+// 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 <string_view>
+#include <chrono>
+#include <cassert>
+
+_LIBSTDAUDIO_NAMESPACE_BEGIN
+
+class audio_device {
+public:
+  audio_device() = delete;
+
+  string_view name() const noexcept {
+    return {};
+  }
+
+  using device_id_t = unsigned;
+
+  device_id_t device_id() const noexcept {
+    return {};
+  }
+
+  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;
+  }
+
+  using sample_rate_t = int;
+
+  sample_rate_t get_sample_rate() const noexcept {
+    return {};
+  }
+
+  span<const sample_rate_t> get_supported_sample_rates() const noexcept {
+    return {};
+  }
+
+  bool set_sample_rate(sample_rate_t) {
+    return false;
+  }
+
+  using buffer_size_t  = int;
+
+  buffer_size_t get_buffer_size_frames() const noexcept {
+    return {};
+  }
+
+  span<const buffer_size_t> get_supported_buffer_sizes_frames() const noexcept {
+    return {};
+  }
+
+  bool set_buffer_size_frames(buffer_size_t) {
+    return false;
+  }
+
+  template <typename _SampleType>
+  constexpr bool supports_sample_type() const noexcept {
+    return false;
+  }
+
+  constexpr bool can_connect() const noexcept {
+    return false;
+  }
+
+  constexpr bool can_process() const noexcept {
+    return false;
+  }
+
+  bool start() {
+    return false;
+  }
+
+  bool stop() {
+    return false;
+  }
+
+  bool is_running() const noexcept {
+    return false;
+  }
+
+  void wait() const {
+    assert(false);
+  }
+
+  template<class _Rep, class _Period>
+  void wait_for(chrono::duration<_Rep, _Period> rel_time) const {
+    assert(false);
+  }
+
+  template<class _Clock, class _Duration>
+  void wait_until(chrono::time_point<_Clock, _Duration> abs_time) const {
+    assert(false);
+  }
+
+  template <typename _CallbackType>
+  void process(_CallbackType&) {
+    assert(false);
+  }
+
+  template <typename _CallbackType>
+  void connect(_CallbackType) {
+    assert(false);
+  }
+};
+
+class audio_device_list
+{
+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_device& {
+      assert(false); static audio_device device{};
+      return device;
+    }
+  };
+
+public:
+  auto begin() -> iterator { return {}; }
+  auto end() -> iterator { return {}; }
+  auto begin() const -> iterator { return {}; }
+  auto end() const -> iterator { return {}; }
+  auto empty() -> bool { return true; }
+};
+
+optional<audio_device> get_default_audio_input_device() {
+  return {};
+}
+
+optional<audio_device> get_default_audio_output_device() {
+  return {};
+}
+
+audio_device_list get_audio_input_device_list() {
+  return {};
+}
+
+audio_device_list get_audio_output_device_list() {
+  return {};
+}
+
+_LIBSTDAUDIO_NAMESPACE_END

From e7ab4c2cdbf6578b00c63f86df1fe93d94428088 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Mon, 20 May 2019 21:51:44 +0100
Subject: [PATCH 10/97] Use forward_list for Windows audio_driver_list

---
 include/audio_backend/__windows_backend.h | 22 ++--------------------
 1 file changed, 2 insertions(+), 20 deletions(-)

diff --git a/include/audio_backend/__windows_backend.h b/include/audio_backend/__windows_backend.h
index 9331f15..b155dc0 100644
--- a/include/audio_backend/__windows_backend.h
+++ b/include/audio_backend/__windows_backend.h
@@ -8,6 +8,7 @@
 #include <string_view>
 #include <chrono>
 #include <cassert>
+#include <forward_list>
 
 _LIBSTDAUDIO_NAMESPACE_BEGIN
 
@@ -119,26 +120,7 @@ class audio_device {
   }
 };
 
-class audio_device_list
-{
-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_device& {
-      assert(false); static audio_device device{};
-      return device;
-    }
-  };
-
-public:
-  auto begin() -> iterator { return {}; }
-  auto end() -> iterator { return {}; }
-  auto begin() const -> iterator { return {}; }
-  auto end() const -> iterator { return {}; }
-  auto empty() -> bool { return true; }
+class audio_device_list : public forward_list<audio_device> {
 };
 
 optional<audio_device> get_default_audio_input_device() {

From 7347d353fd55d43a3c2a033533ef2a313b9f1004 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Mon, 20 May 2019 21:54:22 +0100
Subject: [PATCH 11/97] Move ASIO audio_device class into its own file

---
 include/audio_backend/__asio_audio_device.h | 126 ++++++++++++++++++++
 include/audio_backend/__windows_backend.h   | 120 +------------------
 2 files changed, 130 insertions(+), 116 deletions(-)
 create mode 100644 include/audio_backend/__asio_audio_device.h

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
new file mode 100644
index 0000000..0f7c635
--- /dev/null
+++ b/include/audio_backend/__asio_audio_device.h
@@ -0,0 +1,126 @@
+// libstdaudio
+// Copyright (c) 2019 Andy Saul
+// 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 <string_view>
+#include <chrono>
+#include <cassert>
+#include <forward_list>
+
+_LIBSTDAUDIO_NAMESPACE_BEGIN
+
+class audio_device {
+public:
+  audio_device() = delete;
+
+  string_view name() const noexcept {
+    return {};
+  }
+
+  using device_id_t = unsigned;
+
+  device_id_t device_id() const noexcept {
+    return {};
+  }
+
+  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;
+  }
+
+  using sample_rate_t = int;
+
+  sample_rate_t get_sample_rate() const noexcept {
+    return {};
+  }
+
+  span<const sample_rate_t> get_supported_sample_rates() const noexcept {
+    return {};
+  }
+
+  bool set_sample_rate(sample_rate_t) {
+    return false;
+  }
+
+  using buffer_size_t = int;
+
+  buffer_size_t get_buffer_size_frames() const noexcept {
+    return {};
+  }
+
+  span<const buffer_size_t> get_supported_buffer_sizes_frames() const noexcept {
+    return {};
+  }
+
+  bool set_buffer_size_frames(buffer_size_t) {
+    return false;
+  }
+
+  template <typename _SampleType>
+  constexpr bool supports_sample_type() const noexcept {
+    return false;
+  }
+
+  constexpr bool can_connect() const noexcept {
+    return false;
+  }
+
+  constexpr bool can_process() const noexcept {
+    return false;
+  }
+
+  bool start() {
+    return false;
+  }
+
+  bool stop() {
+    return false;
+  }
+
+  bool is_running() const noexcept {
+    return false;
+  }
+
+  void wait() const {
+    assert(false);
+  }
+
+  template<class _Rep, class _Period>
+  void wait_for(chrono::duration<_Rep, _Period> rel_time) const {
+    assert(false);
+  }
+
+  template<class _Clock, class _Duration>
+  void wait_until(chrono::time_point<_Clock, _Duration> abs_time) const {
+    assert(false);
+  }
+
+  template <typename _CallbackType>
+  void process(_CallbackType&) {
+    assert(false);
+  }
+
+  template <typename _CallbackType>
+  void connect(_CallbackType) {
+    assert(false);
+  }
+};
+
+class audio_device_list : public forward_list<audio_device> {
+};
+
+_LIBSTDAUDIO_NAMESPACE_END
diff --git a/include/audio_backend/__windows_backend.h b/include/audio_backend/__windows_backend.h
index b155dc0..f91c1df 100644
--- a/include/audio_backend/__windows_backend.h
+++ b/include/audio_backend/__windows_backend.h
@@ -1,128 +1,16 @@
 // libstdaudio
-// Copyright (c) 2018 - Timur Doumler
+// Copyright (c) 2018 - 2019 - Timur Doumler, Andy Saul
 // 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 <string_view>
-#include <chrono>
-#include <cassert>
-#include <forward_list>
+#include "__asio_audio_device.h"
 
 _LIBSTDAUDIO_NAMESPACE_BEGIN
 
-class audio_device {
-public:
-  audio_device() = delete;
-
-  string_view name() const noexcept {
-    return {};
-  }
-
-  using device_id_t = unsigned;
-
-  device_id_t device_id() const noexcept {
-    return {};
-  }
-
-  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;
-  }
-
-  using sample_rate_t = int;
-
-  sample_rate_t get_sample_rate() const noexcept {
-    return {};
-  }
-
-  span<const sample_rate_t> get_supported_sample_rates() const noexcept {
-    return {};
-  }
-
-  bool set_sample_rate(sample_rate_t) {
-    return false;
-  }
-
-  using buffer_size_t  = int;
-
-  buffer_size_t get_buffer_size_frames() const noexcept {
-    return {};
-  }
-
-  span<const buffer_size_t> get_supported_buffer_sizes_frames() const noexcept {
-    return {};
-  }
-
-  bool set_buffer_size_frames(buffer_size_t) {
-    return false;
-  }
-
-  template <typename _SampleType>
-  constexpr bool supports_sample_type() const noexcept {
-    return false;
-  }
-
-  constexpr bool can_connect() const noexcept {
-    return false;
-  }
-
-  constexpr bool can_process() const noexcept {
-    return false;
-  }
-
-  bool start() {
-    return false;
-  }
-
-  bool stop() {
-    return false;
-  }
-
-  bool is_running() const noexcept {
-    return false;
-  }
-
-  void wait() const {
-    assert(false);
-  }
-
-  template<class _Rep, class _Period>
-  void wait_for(chrono::duration<_Rep, _Period> rel_time) const {
-    assert(false);
-  }
-
-  template<class _Clock, class _Duration>
-  void wait_until(chrono::time_point<_Clock, _Duration> abs_time) const {
-    assert(false);
-  }
-
-  template <typename _CallbackType>
-  void process(_CallbackType&) {
-    assert(false);
-  }
-
-  template <typename _CallbackType>
-  void connect(_CallbackType) {
-    assert(false);
-  }
-};
-
-class audio_device_list : public forward_list<audio_device> {
-};
-
+// TODO: templatize audio_device as per 6.4 Device Selection API
+// This will allow us to select between ASIO & WASAPI
 optional<audio_device> get_default_audio_input_device() {
   return {};
 }

From 2a860b711560977f63ff07271d52e39fd0ab70a4 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Mon, 20 May 2019 21:56:42 +0100
Subject: [PATCH 12/97] Delegate device selection API calls to __asio_devices

---
 include/audio_backend/__asio_audio_device.h | 28 +++++++++++++++++++++
 include/audio_backend/__windows_backend.h   | 12 ++++++---
 2 files changed, 36 insertions(+), 4 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 0f7c635..5754c29 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -12,6 +12,7 @@
 
 _LIBSTDAUDIO_NAMESPACE_BEGIN
 
+// TODO: templatize audio_device as per 6.4 Device Selection API
 class audio_device {
 public:
   audio_device() = delete;
@@ -123,4 +124,31 @@ class audio_device {
 class audio_device_list : public forward_list<audio_device> {
 };
 
+class __asio_devices {
+public:
+  static __asio_devices& get() {
+    static __asio_devices instance;
+    return instance;
+  }
+
+  optional<audio_device> default_input() {
+    return {};
+  }
+
+  optional<audio_device> default_output() {
+    return {};
+  }
+
+  audio_device_list inputs() {
+    return {};
+  }
+
+  audio_device_list outputs() {
+    return {};
+  }
+
+private:
+  __asio_devices() = default;
+};
+
 _LIBSTDAUDIO_NAMESPACE_END
diff --git a/include/audio_backend/__windows_backend.h b/include/audio_backend/__windows_backend.h
index f91c1df..2a9d140 100644
--- a/include/audio_backend/__windows_backend.h
+++ b/include/audio_backend/__windows_backend.h
@@ -12,19 +12,23 @@ _LIBSTDAUDIO_NAMESPACE_BEGIN
 // TODO: templatize audio_device as per 6.4 Device Selection API
 // This will allow us to select between ASIO & WASAPI
 optional<audio_device> get_default_audio_input_device() {
-  return {};
+  auto& devices = __asio_devices::get();
+  return devices.default_input();
 }
 
 optional<audio_device> get_default_audio_output_device() {
-  return {};
+  auto& devices = __asio_devices::get();
+  return devices.default_output();
 }
 
 audio_device_list get_audio_input_device_list() {
-  return {};
+  auto& devices = __asio_devices::get();
+  return devices.inputs();
 }
 
 audio_device_list get_audio_output_device_list() {
-  return {};
+  auto& devices = __asio_devices::get();
+  return devices.outputs();
 }
 
 _LIBSTDAUDIO_NAMESPACE_END

From bfd8ff624e63d7df949f64cb40c8dc393df49b51 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Mon, 20 May 2019 22:06:32 +0100
Subject: [PATCH 13/97] Read ASIO driver info from registry

---
 include/audio_backend/__asio_audio_device.h | 78 ++++++++++++++++++++-
 1 file changed, 76 insertions(+), 2 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 5754c29..e4c72e8 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -9,11 +9,15 @@
 #include <chrono>
 #include <cassert>
 #include <forward_list>
+#include <vector>
+
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
 
 _LIBSTDAUDIO_NAMESPACE_BEGIN
 
 // TODO: templatize audio_device as per 6.4 Device Selection API
-class audio_device {
+class audio_device final {
 public:
   audio_device() = delete;
 
@@ -124,6 +128,61 @@ class audio_device {
 class audio_device_list : public forward_list<audio_device> {
 };
 
+class __reg_key_reader final
+{
+public:
+  __reg_key_reader(HKEY key, const char* subkey) {
+    const auto result = RegOpenKeyExA(key, subkey, 0, KEY_READ, &_key);
+
+    if (ERROR_SUCCESS != result) {
+      throw runtime_error("Failed to read info from registry: 0x" + result);
+    }
+  }
+
+  ~__reg_key_reader() {
+    if (_key) {
+      RegCloseKey(_key);
+    }
+  }
+
+  vector<string> subkeys() const {
+    constexpr int max_asio_name_length{32};
+    char name[max_asio_name_length];
+    DWORD size{max_asio_name_length};
+    vector<string> keys;
+
+    for (DWORD index{0}; ; ++index) {
+      const auto result = RegEnumKeyEx(_key, index, name, &size, nullptr, nullptr, nullptr, nullptr);
+
+      if (result != ERROR_SUCCESS) {
+        break;
+      }
+
+      keys.emplace_back(name);
+    }
+
+    return keys;
+  }
+
+  __reg_key_reader subkey(const char* name)
+  {
+    return {_key, name};
+  }
+
+  string value(const char* name) const {
+    DWORD size{0};
+    RegQueryValueExA(_key, name, nullptr, nullptr, nullptr, &size);
+
+    string value(size + 1, 0);
+    RegQueryValueExA(_key, name, nullptr, nullptr, LPBYTE(value.data()), &size);
+
+    return value;
+  }
+
+private:
+  HKEY _key{0};
+};
+
 class __asio_devices {
 public:
   static __asio_devices& get() {
@@ -148,7 +207,22 @@ class __asio_devices {
   }
 
 private:
-  __asio_devices() = default;
+  __asio_devices()
+  {
+    enumerate();
+  }
+
+  void enumerate()
+  {
+    __reg_key_reader asio_reg(HKEY_LOCAL_MACHINE, "software\\asio");
+
+    for (const auto& name : asio_reg.subkeys()) {
+      auto key = asio_reg.subkey(name.c_str());
+      auto class_id = key.value("CLSID");
+      class_id = class_id;
+    }
+  }
+
 };
 
 _LIBSTDAUDIO_NAMESPACE_END

From 0ef1a241757993a703198bc5c7bf5e75379abe0c Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Mon, 20 May 2019 22:08:46 +0100
Subject: [PATCH 14/97] Ignore win_build directory

---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index 7c9deb6..596d073 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
 .idea
 cmake-build*
 .DS_Store
+/win_build

From 7f72d5a100b946eb8b2c2248a5c62a84bdf1375b Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Mon, 20 May 2019 22:45:41 +0100
Subject: [PATCH 15/97] Enumerate ASIO devices

---
 include/audio_backend/__asio_audio_device.h |   90 +-
 include/audio_backend/asio.h                | 1070 +++++++++++++++++++
 include/audio_backend/iasiodrv.h            |   35 +
 include/cpp/span.hpp                        |    6 +-
 4 files changed, 1174 insertions(+), 27 deletions(-)
 create mode 100644 include/audio_backend/asio.h
 create mode 100644 include/audio_backend/iasiodrv.h

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index e4c72e8..2a09f7f 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -5,6 +5,8 @@
 
 #pragma once
 
+#include "iasiodrv.h"
+
 #include <string_view>
 #include <chrono>
 #include <cassert>
@@ -13,38 +15,43 @@
 
 #define WIN32_LEAN_AND_MEAN
 #include <Windows.h>
+#include <atlbase.h>
 
 _LIBSTDAUDIO_NAMESPACE_BEGIN
 
 // TODO: templatize audio_device as per 6.4 Device Selection API
 class audio_device final {
 public:
-  audio_device() = delete;
+  using device_id_t = int;
 
-  string_view name() const noexcept {
-    return {};
+  explicit audio_device(device_id_t id, string name, CLSID class_id)
+    : _name(name), _id(id)
+  {
+    initialise_asio(class_id);
   }
 
-  using device_id_t = unsigned;
+  string_view name() const noexcept {
+    return _name;
+  }
 
   device_id_t device_id() const noexcept {
-    return {};
+    return _id;
   }
 
   bool is_input() const noexcept {
-    return false;
+    return _num_inputs > 0;
   }
 
   bool is_output() const noexcept {
-    return false;
+    return _num_outputs > 0;
   }
 
   int get_num_input_channels() const noexcept {
-    return 0;
+    return _num_inputs;
   }
 
   int get_num_output_channels() const noexcept {
-    return 0;
+    return _num_outputs;
   }
 
   using sample_rate_t = int;
@@ -123,6 +130,24 @@ class audio_device final {
   void connect(_CallbackType) {
     assert(false);
   }
+
+private:
+  void initialise_asio(CLSID class_id) {
+    const auto result = CoCreateInstance(class_id, nullptr, CLSCTX_INPROC_SERVER, class_id, reinterpret_cast<void**>(&_asio));
+    if (result) {
+      throw runtime_error("Failed to open ASIO driver: 0x" + result);
+    }
+    if (!_asio->init(nullptr)) {
+      return;
+    }
+    _asio->getChannels(&_num_inputs, &_num_outputs);
+  }
+
+  CComPtr<IASIO> _asio;
+  const string _name;
+  device_id_t _id;
+  long _num_inputs = 0;
+  long _num_outputs = 0;
 };
 
 class audio_device_list : public forward_list<audio_device> {
@@ -131,8 +156,8 @@ class audio_device_list : public forward_list<audio_device> {
 class __reg_key_reader final
 {
 public:
-  __reg_key_reader(HKEY key, const char* subkey) {
-    const auto result = RegOpenKeyExA(key, subkey, 0, KEY_READ, &_key);
+  __reg_key_reader(HKEY key, const string& subkey) {
+    const auto result = RegOpenKeyExA(key, subkey.c_str(), 0, KEY_READ, &_key);
 
     if (ERROR_SUCCESS != result) {
       throw runtime_error("Failed to read info from registry: 0x" + result);
@@ -151,7 +176,7 @@ class __reg_key_reader final
     DWORD size{max_asio_name_length};
     vector<string> keys;
 
-    for (DWORD index{0}; ; ++index) {
+    for (DWORD index = 0; ; ++index) {
       const auto result = RegEnumKeyEx(_key, index, name, &size, nullptr, nullptr, nullptr, nullptr);
 
       if (result != ERROR_SUCCESS) {
@@ -164,7 +189,7 @@ class __reg_key_reader final
     return keys;
   }
 
-  __reg_key_reader subkey(const char* name)
+  __reg_key_reader subkey(const string& name)
   {
     return {_key, name};
   }
@@ -190,6 +215,10 @@ class __asio_devices {
     return instance;
   }
 
+  ~__asio_devices() {
+    CoUninitialize();
+  }
+
   optional<audio_device> default_input() {
     return {};
   }
@@ -199,30 +228,43 @@ class __asio_devices {
   }
 
   audio_device_list inputs() {
-    return {};
+    return enumerate([](const audio_device& device) {
+      return device.is_input();
+    });
   }
 
   audio_device_list outputs() {
-    return {};
+    return enumerate([](const audio_device& device) {
+      return device.is_output();
+    });
   }
 
 private:
-  __asio_devices()
-  {
-    enumerate();
+  __asio_devices() {
+    CoInitialize(nullptr);
   }
 
-  void enumerate()
-  {
+  template <typename Condition>
+  audio_device_list enumerate(Condition condition) {
+    audio_device_list devices;
+
     __reg_key_reader asio_reg(HKEY_LOCAL_MACHINE, "software\\asio");
 
+    int index = 0;
     for (const auto& name : asio_reg.subkeys()) {
-      auto key = asio_reg.subkey(name.c_str());
-      auto class_id = key.value("CLSID");
-      class_id = class_id;
+      const auto key = asio_reg.subkey(name);
+      const auto value = key.value("CLSID");
+
+      CLSID class_id;
+      CLSIDFromString(CComBSTR(value.c_str()), &class_id);
+
+      auto device = audio_device{index++, name, class_id};
+      if (condition(device)) {
+        devices.emplace_front(move(device));
+      }
     }
+    return devices;
   }
-
 };
 
 _LIBSTDAUDIO_NAMESPACE_END
diff --git a/include/audio_backend/asio.h b/include/audio_backend/asio.h
new file mode 100644
index 0000000..341e755
--- /dev/null
+++ b/include/audio_backend/asio.h
@@ -0,0 +1,1070 @@
+//---------------------------------------------------------------------------------------------------
+//---------------------------------------------------------------------------------------------------
+
+/*
+	Steinberg Audio Stream I/O API
+	(c) 1997 - 2013, Steinberg Media Technologies GmbH
+
+	ASIO Interface Specification v 2.3
+
+	2005 - Added support for DSD sample data (in cooperation with Sony)
+	2012 - Added support for drop out detection
+		
+	
+
+	basic concept is an i/o synchronous double-buffer scheme:
+	
+	on bufferSwitch(index == 0), host will read/write:
+
+		after ASIOStart(), the
+  read  first input buffer A (index 0)
+	|   will be invalid (empty)
+	*   ------------------------
+	|------------------------|-----------------------|
+	|                        |                       |
+	|  Input Buffer A (0)    |   Input Buffer B (1)  |
+	|                        |                       |
+	|------------------------|-----------------------|
+	|                        |                       |
+	|  Output Buffer A (0)   |   Output Buffer B (1) |
+	|                        |                       |
+	|------------------------|-----------------------|
+	*                        -------------------------
+	|                        before calling ASIOStart(),
+  write                      host will have filled output
+                             buffer B (index 1) already
+
+  *please* take special care of proper statement of input
+  and output latencies (see ASIOGetLatencies()), these
+  control sequencer sync accuracy
+
+*/
+
+//---------------------------------------------------------------------------------------------------
+//---------------------------------------------------------------------------------------------------
+
+/*
+
+prototypes summary:
+
+ASIOError ASIOInit(ASIODriverInfo *info);
+ASIOError ASIOExit(void);
+ASIOError ASIOStart(void);
+ASIOError ASIOStop(void);
+ASIOError ASIOGetChannels(long *numInputChannels, long *numOutputChannels);
+ASIOError ASIOGetLatencies(long *inputLatency, long *outputLatency);
+ASIOError ASIOGetBufferSize(long *minSize, long *maxSize, long *preferredSize, long *granularity);
+ASIOError ASIOCanSampleRate(ASIOSampleRate sampleRate);
+ASIOError ASIOGetSampleRate(ASIOSampleRate *currentRate);
+ASIOError ASIOSetSampleRate(ASIOSampleRate sampleRate);
+ASIOError ASIOGetClockSources(ASIOClockSource *clocks, long *numSources);
+ASIOError ASIOSetClockSource(long reference);
+ASIOError ASIOGetSamplePosition (ASIOSamples *sPos, ASIOTimeStamp *tStamp);
+ASIOError ASIOGetChannelInfo(ASIOChannelInfo *info);
+ASIOError ASIOCreateBuffers(ASIOBufferInfo *bufferInfos, long numChannels,
+	long bufferSize, ASIOCallbacks *callbacks);
+ASIOError ASIODisposeBuffers(void);
+ASIOError ASIOControlPanel(void);
+void *ASIOFuture(long selector, void *params);
+ASIOError ASIOOutputReady(void);
+
+*/
+
+//---------------------------------------------------------------------------------------------------
+//---------------------------------------------------------------------------------------------------
+
+#ifndef __ASIO_H
+#define __ASIO_H
+
+// force 4 byte alignment
+#if defined(_MSC_VER) && !defined(__MWERKS__) 
+#pragma pack(push,4)
+#elif PRAGMA_ALIGN_SUPPORTED
+#pragma options align = native
+#endif
+
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+// Type definitions
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+
+// number of samples data type is 64 bit integer
+#if NATIVE_INT64
+	typedef long long int ASIOSamples;
+#else
+	typedef struct ASIOSamples {
+		unsigned long hi;
+		unsigned long lo;
+	} ASIOSamples;
+#endif
+
+// Timestamp data type is 64 bit integer,
+// Time format is Nanoseconds.
+#if NATIVE_INT64
+	typedef long long int ASIOTimeStamp ;
+#else
+	typedef struct ASIOTimeStamp {
+		unsigned long hi;
+		unsigned long lo;
+	} ASIOTimeStamp;
+#endif
+
+// Samplerates are expressed in IEEE 754 64 bit double float,
+// native format as host computer
+#if IEEE754_64FLOAT
+	typedef double ASIOSampleRate;
+#else
+	typedef struct ASIOSampleRate {
+		char ieee[8];
+	} ASIOSampleRate;
+#endif
+
+// Boolean values are expressed as long
+typedef long ASIOBool;
+enum {
+	ASIOFalse = 0,
+	ASIOTrue = 1
+};
+
+// Sample Types are expressed as long
+typedef long ASIOSampleType;
+enum {
+	ASIOSTInt16MSB   = 0,
+	ASIOSTInt24MSB   = 1,		// used for 20 bits as well
+	ASIOSTInt32MSB   = 2,
+	ASIOSTFloat32MSB = 3,		// IEEE 754 32 bit float
+	ASIOSTFloat64MSB = 4,		// IEEE 754 64 bit double float
+
+	// these are used for 32 bit data buffer, with different alignment of the data inside
+	// 32 bit PCI bus systems can be more easily used with these
+	ASIOSTInt32MSB16 = 8,		// 32 bit data with 16 bit alignment
+	ASIOSTInt32MSB18 = 9,		// 32 bit data with 18 bit alignment
+	ASIOSTInt32MSB20 = 10,		// 32 bit data with 20 bit alignment
+	ASIOSTInt32MSB24 = 11,		// 32 bit data with 24 bit alignment
+	
+	ASIOSTInt16LSB   = 16,
+	ASIOSTInt24LSB   = 17,		// used for 20 bits as well
+	ASIOSTInt32LSB   = 18,
+	ASIOSTFloat32LSB = 19,		// IEEE 754 32 bit float, as found on Intel x86 architecture
+	ASIOSTFloat64LSB = 20, 		// IEEE 754 64 bit double float, as found on Intel x86 architecture
+
+	// these are used for 32 bit data buffer, with different alignment of the data inside
+	// 32 bit PCI bus systems can more easily used with these
+	ASIOSTInt32LSB16 = 24,		// 32 bit data with 18 bit alignment
+	ASIOSTInt32LSB18 = 25,		// 32 bit data with 18 bit alignment
+	ASIOSTInt32LSB20 = 26,		// 32 bit data with 20 bit alignment
+	ASIOSTInt32LSB24 = 27,		// 32 bit data with 24 bit alignment
+
+	//	ASIO DSD format.
+	ASIOSTDSDInt8LSB1   = 32,		// DSD 1 bit data, 8 samples per byte. First sample in Least significant bit.
+	ASIOSTDSDInt8MSB1   = 33,		// DSD 1 bit data, 8 samples per byte. First sample in Most significant bit.
+	ASIOSTDSDInt8NER8	= 40,		// DSD 8 bit data, 1 sample per byte. No Endianness required.
+
+	ASIOSTLastEntry
+};
+
+/*-----------------------------------------------------------------------------
+// DSD operation and buffer layout
+// Definition by Steinberg/Sony Oxford.
+//
+// We have tried to treat DSD as PCM and so keep a consistant structure across
+// the ASIO interface.
+//
+// DSD's sample rate is normally referenced as a multiple of 44.1Khz, so
+// the standard sample rate is refered to as 64Fs (or 2.8224Mhz). We looked
+// at making a special case for DSD and adding a field to the ASIOFuture that
+// would allow the user to select the Over Sampleing Rate (OSR) as a seperate
+// entity but decided in the end just to treat it as a simple value of
+// 2.8224Mhz and use the standard interface to set it.
+//
+// The second problem was the "word" size, in PCM the word size is always a
+// greater than or equal to 8 bits (a byte). This makes life easy as we can
+// then pack the samples into the "natural" size for the machine.
+// In DSD the "word" size is 1 bit. This is not a major problem and can easily
+// be dealt with if we ensure that we always deal with a multiple of 8 samples.
+//
+// DSD brings with it another twist to the Endianness religion. How are the
+// samples packed into the byte. It would be nice to just say the most significant
+// bit is always the first sample, however there would then be a performance hit
+// on little endian machines. Looking at how some of the processing goes...
+// Little endian machines like the first sample to be in the Least Significant Bit,
+//   this is because when you write it to memory the data is in the correct format
+//   to be shifted in and out of the words.
+// Big endian machine prefer the first sample to be in the Most Significant Bit,
+//   again for the same reasion.
+//
+// And just when things were looking really muddy there is a proposed extension to
+// DSD that uses 8 bit word sizes. It does not care what endianness you use.
+//
+// Switching the driver between DSD and PCM mode
+// ASIOFuture allows for extending the ASIO API quite transparently.
+// See kAsioSetIoFormat, kAsioGetIoFormat, kAsioCanDoIoFormat
+//
+//-----------------------------------------------------------------------------*/
+
+
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+// Error codes
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+
+typedef long ASIOError;
+enum {
+	ASE_OK = 0,             // This value will be returned whenever the call succeeded
+	ASE_SUCCESS = 0x3f4847a0,	// unique success return value for ASIOFuture calls
+	ASE_NotPresent = -1000, // hardware input or output is not present or available
+	ASE_HWMalfunction,      // hardware is malfunctioning (can be returned by any ASIO function)
+	ASE_InvalidParameter,   // input parameter invalid
+	ASE_InvalidMode,        // hardware is in a bad mode or used in a bad mode
+	ASE_SPNotAdvancing,     // hardware is not running when sample position is inquired
+	ASE_NoClock,            // sample clock or rate cannot be determined or is not present
+	ASE_NoMemory            // not enough memory for completing the request
+};
+
+//---------------------------------------------------------------------------------------------------
+//---------------------------------------------------------------------------------------------------
+
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+// Time Info support
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+
+typedef struct ASIOTimeCode
+{       
+	double          speed;                  // speed relation (fraction of nominal speed)
+	                                        // optional; set to 0. or 1. if not supported
+	ASIOSamples     timeCodeSamples;        // time in samples
+	unsigned long   flags;                  // some information flags (see below)
+	char future[64];
+} ASIOTimeCode;
+
+typedef enum ASIOTimeCodeFlags
+{
+	kTcValid                = 1,
+	kTcRunning              = 1 << 1,
+	kTcReverse              = 1 << 2,
+	kTcOnspeed              = 1 << 3,
+	kTcStill                = 1 << 4,
+	
+	kTcSpeedValid           = 1 << 8
+}  ASIOTimeCodeFlags;
+
+typedef struct AsioTimeInfo
+{
+	double          speed;                  // absolute speed (1. = nominal)
+	ASIOTimeStamp   systemTime;             // system time related to samplePosition, in nanoseconds
+	                                        // on mac, must be derived from Microseconds() (not UpTime()!)
+	                                        // on windows, must be derived from timeGetTime()
+	ASIOSamples     samplePosition;
+	ASIOSampleRate  sampleRate;             // current rate
+	unsigned long flags;                    // (see below)
+	char reserved[12];
+} AsioTimeInfo;
+
+typedef enum AsioTimeInfoFlags
+{
+	kSystemTimeValid        = 1,            // must always be valid
+	kSamplePositionValid    = 1 << 1,       // must always be valid
+	kSampleRateValid        = 1 << 2,
+	kSpeedValid             = 1 << 3,
+	
+	kSampleRateChanged      = 1 << 4,
+	kClockSourceChanged     = 1 << 5
+} AsioTimeInfoFlags;
+
+typedef struct ASIOTime                          // both input/output
+{
+	long reserved[4];                       // must be 0
+	struct AsioTimeInfo     timeInfo;       // required
+	struct ASIOTimeCode     timeCode;       // optional, evaluated if (timeCode.flags & kTcValid)
+} ASIOTime;
+
+/*
+
+using time info:
+it is recommended to use the new method with time info even if the asio
+device does not support timecode; continuous calls to ASIOGetSamplePosition
+and ASIOGetSampleRate are avoided, and there is a more defined relationship
+between callback time and the time info.
+
+see the example below.
+to initiate time info mode, after you have received the callbacks pointer in
+ASIOCreateBuffers, you will call the asioMessage callback with kAsioSupportsTimeInfo
+as the argument. if this returns 1, host has accepted time info mode.
+now host expects the new callback bufferSwitchTimeInfo to be used instead
+of the old bufferSwitch method. the ASIOTime structure is assumed to be valid
+and accessible until the callback returns.
+
+using time code:
+if the device supports reading time code, it will call host's asioMessage callback
+with kAsioSupportsTimeCode as the selector. it may then fill the according
+fields and set the kTcValid flag.
+host will call the future method with the kAsioEnableTimeCodeRead selector when
+it wants to enable or disable tc reading by the device. you should also support
+the kAsioCanTimeInfo and kAsioCanTimeCode selectors in ASIOFuture (see example).
+
+note:
+the AsioTimeInfo/ASIOTimeCode pair is supposed to work in both directions.
+as a matter of convention, the relationship between the sample
+position counter and the time code at buffer switch time is
+(ignoring offset between tc and sample pos when tc is running):
+
+on input:	sample 0 -> input  buffer sample 0 -> time code 0
+on output:	sample 0 -> output buffer sample 0 -> time code 0
+
+this means that for 'real' calculations, one has to take into account
+the according latencies.
+
+example:
+
+ASIOTime asioTime;
+
+in createBuffers()
+{
+	memset(&asioTime, 0, sizeof(ASIOTime));
+	AsioTimeInfo* ti = &asioTime.timeInfo;
+	ti->sampleRate = theSampleRate;
+	ASIOTimeCode* tc = &asioTime.timeCode;
+	tc->speed = 1.;
+	timeInfoMode = false;
+	canTimeCode = false;
+	if(callbacks->asioMessage(kAsioSupportsTimeInfo, 0, 0, 0) == 1)
+	{
+		timeInfoMode = true;
+#if kCanTimeCode
+		if(callbacks->asioMessage(kAsioSupportsTimeCode, 0, 0, 0) == 1)
+			canTimeCode = true;
+#endif
+	}
+}
+
+void switchBuffers(long doubleBufferIndex, bool processNow)
+{
+	if(timeInfoMode)
+	{
+		AsioTimeInfo* ti = &asioTime.timeInfo;
+		ti->flags =	kSystemTimeValid | kSamplePositionValid | kSampleRateValid;
+		ti->systemTime = theNanoSeconds;
+		ti->samplePosition = theSamplePosition;
+		if(ti->sampleRate != theSampleRate)
+			ti->flags |= kSampleRateChanged;
+		ti->sampleRate = theSampleRate;
+
+#if kCanTimeCode
+		if(canTimeCode && timeCodeEnabled)
+		{
+			ASIOTimeCode* tc = &asioTime.timeCode;
+			tc->timeCodeSamples = tcSamples;						// tc in samples
+			tc->flags = kTcValid | kTcRunning | kTcOnspeed;			// if so...
+		}
+		ASIOTime* bb = callbacks->bufferSwitchTimeInfo(&asioTime, doubleBufferIndex, processNow ? ASIOTrue : ASIOFalse);
+#else
+		callbacks->bufferSwitchTimeInfo(&asioTime, doubleBufferIndex, processNow ? ASIOTrue : ASIOFalse);
+#endif
+	}
+	else
+		callbacks->bufferSwitch(doubleBufferIndex, ASIOFalse);
+}
+
+ASIOError ASIOFuture(long selector, void *params)
+{
+	switch(selector)
+	{
+		case kAsioEnableTimeCodeRead:
+			timeCodeEnabled = true;
+			return ASE_SUCCESS;
+		case kAsioDisableTimeCodeRead:
+			timeCodeEnabled = false;
+			return ASE_SUCCESS;
+		case kAsioCanTimeInfo:
+			return ASE_SUCCESS;
+		#if kCanTimeCode
+		case kAsioCanTimeCode:
+			return ASE_SUCCESS;
+		#endif
+	}
+	return ASE_NotPresent;
+};
+
+*/
+
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+// application's audio stream handler callbacks
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+
+typedef struct ASIOCallbacks
+{
+	void (*bufferSwitch) (long doubleBufferIndex, ASIOBool directProcess);
+		// bufferSwitch indicates that both input and output are to be processed.
+		// the current buffer half index (0 for A, 1 for B) determines
+		// - the output buffer that the host should start to fill. the other buffer
+		//   will be passed to output hardware regardless of whether it got filled
+		//   in time or not.
+		// - the input buffer that is now filled with incoming data. Note that
+		//   because of the synchronicity of i/o, the input always has at
+		//   least one buffer latency in relation to the output.
+		// directProcess suggests to the host whether it should immedeately
+		// start processing (directProcess == ASIOTrue), or whether its process
+		// should be deferred because the call comes from a very low level
+		// (for instance, a high level priority interrupt), and direct processing
+		// would cause timing instabilities for the rest of the system. If in doubt,
+		// directProcess should be set to ASIOFalse.
+		// Note: bufferSwitch may be called at interrupt time for highest efficiency.
+
+	void (*sampleRateDidChange) (ASIOSampleRate sRate);
+		// gets called when the AudioStreamIO detects a sample rate change
+		// If sample rate is unknown, 0 is passed (for instance, clock loss
+		// when externally synchronized).
+
+	long (*asioMessage) (long selector, long value, void* message, double* opt);
+		// generic callback for various purposes, see selectors below.
+		// note this is only present if the asio version is 2 or higher
+
+	ASIOTime* (*bufferSwitchTimeInfo) (ASIOTime* params, long doubleBufferIndex, ASIOBool directProcess);
+		// new callback with time info. makes ASIOGetSamplePosition() and various
+		// calls to ASIOGetSampleRate obsolete,
+		// and allows for timecode sync etc. to be preferred; will be used if
+		// the driver calls asioMessage with selector kAsioSupportsTimeInfo.
+} ASIOCallbacks;
+
+// asioMessage selectors
+enum
+{
+	kAsioSelectorSupported = 1,	// selector in <value>, returns 1L if supported,
+								// 0 otherwise
+    kAsioEngineVersion,			// returns engine (host) asio implementation version,
+								// 2 or higher
+	kAsioResetRequest,			// request driver reset. if accepted, this
+								// will close the driver (ASIO_Exit() ) and
+								// re-open it again (ASIO_Init() etc). some
+								// drivers need to reconfigure for instance
+								// when the sample rate changes, or some basic
+								// changes have been made in ASIO_ControlPanel().
+								// returns 1L; note the request is merely passed
+								// to the application, there is no way to determine
+								// if it gets accepted at this time (but it usually
+								// will be).
+	kAsioBufferSizeChange,		// not yet supported, will currently always return 0L.
+								// for now, use kAsioResetRequest instead.
+								// once implemented, the new buffer size is expected
+								// in <value>, and on success returns 1L
+	kAsioResyncRequest,			// the driver went out of sync, such that
+								// the timestamp is no longer valid. this
+								// is a request to re-start the engine and
+								// slave devices (sequencer). returns 1 for ok,
+								// 0 if not supported.
+	kAsioLatenciesChanged, 		// the drivers latencies have changed. The engine
+								// will refetch the latencies.
+	kAsioSupportsTimeInfo,		// if host returns true here, it will expect the
+								// callback bufferSwitchTimeInfo to be called instead
+								// of bufferSwitch
+	kAsioSupportsTimeCode,		// 
+	kAsioMMCCommand,			// unused - value: number of commands, message points to mmc commands
+	kAsioSupportsInputMonitor,	// kAsioSupportsXXX return 1 if host supports this
+	kAsioSupportsInputGain,     // unused and undefined
+	kAsioSupportsInputMeter,    // unused and undefined
+	kAsioSupportsOutputGain,    // unused and undefined
+	kAsioSupportsOutputMeter,   // unused and undefined
+	kAsioOverload,              // driver detected an overload
+
+	kAsioNumMessageSelectors
+};
+
+//---------------------------------------------------------------------------------------------------
+//---------------------------------------------------------------------------------------------------
+
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+// (De-)Construction
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+
+typedef struct ASIODriverInfo
+{
+	long asioVersion;		// currently, 2
+	long driverVersion;		// driver specific
+	char name[32];
+	char errorMessage[124];
+	void *sysRef;			// on input: system reference
+							// (Windows: application main window handle, Mac & SGI: 0)
+} ASIODriverInfo;
+
+ASIOError ASIOInit(ASIODriverInfo *info);
+/* Purpose:
+	  Initialize the AudioStreamIO.
+	Parameter:
+	  info: pointer to an ASIODriver structure:
+	    - asioVersion:
+			- on input, the host version. *** Note *** this is 0 for earlier asio
+			implementations, and the asioMessage callback is implemeted
+			only if asioVersion is 2 or greater. sorry but due to a design fault
+			the driver doesn't have access to the host version in ASIOInit :-(
+			added selector for host (engine) version in the asioMessage callback
+			so we're ok from now on.
+			- on return, asio implementation version.
+			  older versions are 1
+			  if you support this version (namely, ASIO_outputReady() )
+			  this should be 2 or higher. also see the note in
+			  ASIO_getTimeStamp() !
+	    - version: on return, the driver version (format is driver specific)
+	    - name: on return, a null-terminated string containing the driver's name
+		- error message: on return, should contain a user message describing
+		  the type of error that occured during ASIOInit(), if any.
+		- sysRef: platform specific
+	Returns:
+	  If neither input nor output is present ASE_NotPresent
+	  will be returned.
+	  ASE_NoMemory, ASE_HWMalfunction are other possible error conditions
+*/
+
+ASIOError ASIOExit(void);
+/* Purpose:
+	  Terminates the AudioStreamIO.
+	Parameter:
+	  None.
+	Returns:
+	  If neither input nor output is present ASE_NotPresent
+	  will be returned.
+	Notes: this implies ASIOStop() and ASIODisposeBuffers(),
+	  meaning that no host callbacks must be accessed after ASIOExit().
+*/
+
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+// Start/Stop
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+
+ASIOError ASIOStart(void);
+/* Purpose:
+	  Start input and output processing synchronously.
+	  This will
+	  - reset the sample counter to zero
+	  - start the hardware (both input and output)
+	    The first call to the hosts' bufferSwitch(index == 0) then tells
+	    the host to read from input buffer A (index 0), and start
+	    processing to output buffer A while output buffer B (which
+	    has been filled by the host prior to calling ASIOStart())
+	    is possibly sounding (see also ASIOGetLatencies()) 
+	Parameter:
+	  None.
+	Returns:
+	  If neither input nor output is present, ASE_NotPresent
+	  will be returned.
+	  If the hardware fails to start, ASE_HWMalfunction will be returned.
+	Notes:
+	  There is no restriction on the time that ASIOStart() takes
+	  to perform (that is, it is not considered a realtime trigger).
+*/
+
+ASIOError ASIOStop(void);
+/* Purpose:
+	  Stops input and output processing altogether.
+	Parameter:
+	  None.
+	Returns:
+	  If neither input nor output is present ASE_NotPresent
+	  will be returned.
+	Notes:
+	  On return from ASIOStop(), the driver must in no
+	  case call the hosts' bufferSwitch() routine.
+*/
+
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+// Inquiry methods and sample rate
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+
+ASIOError ASIOGetChannels(long *numInputChannels, long *numOutputChannels);
+/* Purpose:
+	  Returns number of individual input/output channels.
+	Parameter:
+	  numInputChannels will hold the number of available input channels
+	  numOutputChannels will hold the number of available output channels
+	Returns:
+	  If no input/output is present ASE_NotPresent will be returned.
+	  If only inputs, or only outputs are available, the according
+	  other parameter will be zero, and ASE_OK is returned.
+*/
+
+ASIOError ASIOGetLatencies(long *inputLatency, long *outputLatency);
+/* Purpose:
+	  Returns the input and output latencies. This includes
+	  device specific delays, like FIFOs etc.
+	Parameter:
+	  inputLatency will hold the 'age' of the first sample frame
+	  in the input buffer when the hosts reads it in bufferSwitch()
+	  (this is theoretical, meaning it does not include the overhead
+	  and delay between the actual physical switch, and the time
+	  when bufferSitch() enters).
+	  This will usually be the size of one block in sample frames, plus
+	  device specific latencies.
+
+	  outputLatency will specify the time between the buffer switch,
+	  and the time when the next play buffer will start to sound.
+	  The next play buffer is defined as the one the host starts
+	  processing after (or at) bufferSwitch(), indicated by the
+	  index parameter (0 for buffer A, 1 for buffer B).
+	  It will usually be either one block, if the host writes directly
+	  to a dma buffer, or two or more blocks if the buffer is 'latched' by
+	  the driver. As an example, on ASIOStart(), the host will have filled
+	  the play buffer at index 1 already; when it gets the callback (with
+	  the parameter index == 0), this tells it to read from the input
+	  buffer 0, and start to fill the play buffer 0 (assuming that now
+	  play buffer 1 is already sounding). In this case, the output
+	  latency is one block. If the driver decides to copy buffer 1
+	  at that time, and pass it to the hardware at the next slot (which
+	  is most commonly done, but should be avoided), the output latency
+	  becomes two blocks instead, resulting in a total i/o latency of at least
+	  3 blocks. As memory access is the main bottleneck in native dsp processing,
+	  and to acheive less latency, it is highly recommended to try to avoid
+	  copying (this is also why the driver is the owner of the buffers). To
+	  summarize, the minimum i/o latency can be acheived if the input buffer
+	  is processed by the host into the output buffer which will physically
+	  start to sound on the next time slice. Also note that the host expects
+	  the bufferSwitch() callback to be accessed for each time slice in order
+	  to retain sync, possibly recursively; if it fails to process a block in
+	  time, it will suspend its operation for some time in order to recover.
+	Returns:
+	  If no input/output is present ASE_NotPresent will be returned.
+*/
+
+ASIOError ASIOGetBufferSize(long *minSize, long *maxSize, long *preferredSize, long *granularity);
+/* Purpose:
+	  Returns min, max, and preferred buffer sizes for input/output
+	Parameter:
+	  minSize will hold the minimum buffer size
+	  maxSize will hold the maxium possible buffer size
+	  preferredSize will hold the preferred buffer size (a size which
+	  best fits performance and hardware requirements)
+	  granularity will hold the granularity at which buffer sizes
+	  may differ. Usually, the buffer size will be a power of 2;
+	  in this case, granularity will hold -1 on return, signalling
+	  possible buffer sizes starting from minSize, increased in
+	  powers of 2 up to maxSize.
+	Returns:
+	  If no input/output is present ASE_NotPresent will be returned.
+	Notes:
+	  When minimum and maximum buffer size are equal,
+	  the preferred buffer size has to be the same value as well; granularity
+	  should be 0 in this case.
+*/
+
+ASIOError ASIOCanSampleRate(ASIOSampleRate sampleRate);
+/* Purpose:
+	  Inquires the hardware for the available sample rates.
+	Parameter:
+	  sampleRate is the rate in question.
+	Returns:
+	  If the inquired sample rate is not supported, ASE_NoClock will be returned.
+	  If no input/output is present ASE_NotPresent will be returned.
+*/
+ASIOError ASIOGetSampleRate(ASIOSampleRate *currentRate);
+/* Purpose:
+	  Get the current sample Rate.
+	Parameter:
+	  currentRate will hold the current sample rate on return.
+	Returns:
+	  If sample rate is unknown, sampleRate will be 0 and ASE_NoClock will be returned.
+	  If no input/output is present ASE_NotPresent will be returned.
+	Notes:
+*/
+
+ASIOError ASIOSetSampleRate(ASIOSampleRate sampleRate);
+/* Purpose:
+	  Set the hardware to the requested sample Rate. If sampleRate == 0,
+	  enable external sync.
+	Parameter:
+	  sampleRate: on input, the requested rate
+	Returns:
+	  If sampleRate is unknown ASE_NoClock will be returned.
+	  If the current clock is external, and sampleRate is != 0,
+	  ASE_InvalidMode will be returned
+	  If no input/output is present ASE_NotPresent will be returned.
+	Notes:
+*/
+
+typedef struct ASIOClockSource
+{
+	long index;					// as used for ASIOSetClockSource()
+	long associatedChannel;		// for instance, S/PDIF or AES/EBU
+	long associatedGroup;		// see channel groups (ASIOGetChannelInfo())
+	ASIOBool isCurrentSource;	// ASIOTrue if this is the current clock source
+	char name[32];				// for user selection
+} ASIOClockSource;
+
+ASIOError ASIOGetClockSources(ASIOClockSource *clocks, long *numSources);
+/* Purpose:
+	  Get the available external audio clock sources
+	Parameter:
+	  clocks points to an array of ASIOClockSource structures:
+	  	- index: this is used to identify the clock source
+	  	  when ASIOSetClockSource() is accessed, should be
+	  	  an index counting from zero
+	  	- associatedInputChannel: the first channel of an associated
+	  	  input group, if any.
+	  	- associatedGroup: the group index of that channel.
+	  	  groups of channels are defined to seperate for
+	  	  instance analog, S/PDIF, AES/EBU, ADAT connectors etc,
+	  	  when present simultaniously. Note that associated channel
+	  	  is enumerated according to numInputs/numOutputs, means it
+	  	  is independant from a group (see also ASIOGetChannelInfo())
+	  	  inputs are associated to a clock if the physical connection
+	  	  transfers both data and clock (like S/PDIF, AES/EBU, or
+	  	  ADAT inputs). if there is no input channel associated with
+	  	  the clock source (like Word Clock, or internal oscillator), both
+	  	  associatedChannel and associatedGroup should be set to -1.
+	  	- isCurrentSource: on exit, ASIOTrue if this is the current clock
+	  	  source, ASIOFalse else
+		- name: a null-terminated string for user selection of the available sources.
+	  numSources:
+	      on input: the number of allocated array members
+	      on output: the number of available clock sources, at least
+	      1 (internal clock generator).
+	Returns:
+	  If no input/output is present ASE_NotPresent will be returned.
+	Notes:
+*/
+
+ASIOError ASIOSetClockSource(long index);
+/* Purpose:
+	  Set the audio clock source
+	Parameter:
+	  index as obtained from an inquiry to ASIOGetClockSources()
+	Returns:
+	  If no input/output is present ASE_NotPresent will be returned.
+	  If the clock can not be selected because an input channel which
+	  carries the current clock source is active, ASE_InvalidMode
+	  *may* be returned (this depends on the properties of the driver
+	  and/or hardware).
+	Notes:
+	  Should *not* return ASE_NoClock if there is no clock signal present
+	  at the selected source; this will be inquired via ASIOGetSampleRate().
+	  It should call the host callback procedure sampleRateHasChanged(),
+	  if the switch causes a sample rate change, or if no external clock
+	  is present at the selected source.
+*/
+
+ASIOError ASIOGetSamplePosition (ASIOSamples *sPos, ASIOTimeStamp *tStamp);
+/* Purpose:
+	  Inquires the sample position/time stamp pair.
+	Parameter:
+	  sPos will hold the sample position on return. The sample
+	  position is reset to zero when ASIOStart() gets called.
+	  tStamp will hold the system time when the sample position
+	  was latched.
+	Returns:
+	  If no input/output is present, ASE_NotPresent will be returned.
+	  If there is no clock, ASE_SPNotAdvancing will be returned.
+	Notes:
+
+	  in order to be able to synchronise properly,
+	  the sample position / time stamp pair must refer to the current block,
+	  that is, the engine will call ASIOGetSamplePosition() in its bufferSwitch()
+	  callback and expect the time for the current block. thus, when requested
+	  in the very first bufferSwitch after ASIO_Start(), the sample position
+	  should be zero, and the time stamp should refer to the very time where
+	  the stream was started. it also means that the sample position must be
+	  block aligned. the driver must ensure proper interpolation if the system
+	  time can not be determined for the block position. the driver is responsible
+	  for precise time stamps as it usually has most direct access to lower
+	  level resources. proper behaviour of ASIO_GetSamplePosition() and ASIO_GetLatencies()
+	  are essential for precise media synchronization!
+*/
+
+typedef struct ASIOChannelInfo
+{
+	long channel;			// on input, channel index
+	ASIOBool isInput;		// on input
+	ASIOBool isActive;		// on exit
+	long channelGroup;		// dto
+	ASIOSampleType type;	// dto
+	char name[32];			// dto
+} ASIOChannelInfo;
+
+ASIOError ASIOGetChannelInfo(ASIOChannelInfo *info);
+/* Purpose:
+	  retreive information about the nature of a channel
+	Parameter:
+	  info: pointer to a ASIOChannelInfo structure with
+	  	- channel: on input, the channel index of the channel in question.
+	  	- isInput: on input, ASIOTrue if info for an input channel is
+	  	  requested, else output
+		- channelGroup: on return, the channel group that the channel
+		  belongs to. For drivers which support different types of
+		  channels, like analog, S/PDIF, AES/EBU, ADAT etc interfaces,
+		  there should be a reasonable grouping of these types. Groups
+		  are always independant form a channel index, that is, a channel
+		  index always counts from 0 to numInputs/numOutputs regardless
+		  of the group it may belong to.
+		  There will always be at least one group (group 0). Please
+		  also note that by default, the host may decide to activate
+		  channels 0 and 1; thus, these should belong to the most
+		  useful type (analog i/o, if present).
+	  	- type: on return, contains the sample type of the channel
+	  	- isActive: on return, ASIOTrue if channel is active as it was
+	  	  installed by ASIOCreateBuffers(), ASIOFalse else
+	  	- name:  describing the type of channel in question. Used to allow
+	  	  for user selection, and enabling of specific channels. examples:
+	      "Analog In", "SPDIF Out" etc
+	Returns:
+	  If no input/output is present ASE_NotPresent will be returned.
+	Notes:
+	  If possible, the string should be organised such that the first
+	  characters are most significantly describing the nature of the
+	  port, to allow for identification even if the view showing the
+	  port name is too small to display more than 8 characters, for
+	  instance.
+*/
+
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+// Buffer preparation
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+
+typedef struct ASIOBufferInfo
+{
+	ASIOBool isInput;			// on input:  ASIOTrue: input, else output
+	long channelNum;			// on input:  channel index
+	void *buffers[2];			// on output: double buffer addresses
+} ASIOBufferInfo;
+
+ASIOError ASIOCreateBuffers(ASIOBufferInfo *bufferInfos, long numChannels,
+	long bufferSize, ASIOCallbacks *callbacks);
+
+/* Purpose:
+	  Allocates input/output buffers for all input and output channels to be activated.
+	Parameter:
+	  bufferInfos is a pointer to an array of ASIOBufferInfo structures:
+	    - isInput: on input, ASIOTrue if the buffer is to be allocated
+	      for an input, output buffer else
+	    - channelNum: on input, the index of the channel in question
+	      (counting from 0)
+	    - buffers: on exit, 2 pointers to the halves of the channels' double-buffer.
+	      the size of the buffer(s) of course depend on both the ASIOSampleType
+	      as obtained from ASIOGetChannelInfo(), and bufferSize
+	  numChannels is the sum of all input and output channels to be created;
+	  thus bufferInfos is a pointer to an array of numChannels ASIOBufferInfo
+	  structures.
+	  bufferSize selects one of the possible buffer sizes as obtained from
+	  ASIOGetBufferSizes().
+	  callbacks is a pointer to an ASIOCallbacks structure.
+	Returns:
+	  If not enough memory is available ASE_NoMemory will be returned.
+	  If no input/output is present ASE_NotPresent will be returned.
+	  If bufferSize is not supported, or one or more of the bufferInfos elements
+	  contain invalid settings, ASE_InvalidMode will be returned.
+	Notes:
+	  If individual channel selection is not possible but requested,
+	  the driver has to handle this. namely, bufferSwitch() will only
+	  have filled buffers of enabled outputs. If possible, processing
+	  and buss activities overhead should be avoided for channels which
+	  were not enabled here.
+*/
+
+ASIOError ASIODisposeBuffers(void);
+/* Purpose:
+	  Releases all buffers for the device.
+	Parameter:
+	  None.
+	Returns:
+	  If no buffer were ever prepared, ASE_InvalidMode will be returned.
+	  If no input/output is present ASE_NotPresent will be returned.
+	Notes:
+	  This implies ASIOStop().
+*/
+
+ASIOError ASIOControlPanel(void);
+/* Purpose:
+	  request the driver to start a control panel component
+	  for device specific user settings. This will not be
+	  accessed on some platforms (where the component is accessed
+	  instead).
+	Parameter:
+	  None.
+	Returns:
+	  If no panel is available ASE_NotPresent will be returned.
+	  Actually, the return code is ignored.
+	Notes:
+	  if the user applied settings which require a re-configuration
+	  of parts or all of the enigine and/or driver (such as a change of
+	  the block size), the asioMessage callback can be used (see
+	  ASIO_Callbacks).
+*/
+
+ASIOError ASIOFuture(long selector, void *params);
+/* Purpose:
+	  various
+	Parameter:
+	  selector: operation Code as to be defined. zero is reserved for
+	  testing purposes.
+	  params: depends on the selector; usually pointer to a structure
+	  for passing and retreiving any type and amount of parameters.
+	Returns:
+	  the return value is also selector dependant. if the selector
+	  is unknown, ASE_InvalidParameter should be returned to prevent
+	  further calls with this selector. on success, ASE_SUCCESS
+	  must be returned (note: ASE_OK is *not* sufficient!)
+	Notes:
+	  see selectors defined below.	  
+*/
+
+enum
+{
+	kAsioEnableTimeCodeRead = 1,	// no arguments
+	kAsioDisableTimeCodeRead,		// no arguments
+	kAsioSetInputMonitor,			// ASIOInputMonitor* in params
+	kAsioTransport,					// ASIOTransportParameters* in params
+	kAsioSetInputGain,				// ASIOChannelControls* in params, apply gain
+	kAsioGetInputMeter,				// ASIOChannelControls* in params, fill meter
+	kAsioSetOutputGain,				// ASIOChannelControls* in params, apply gain
+	kAsioGetOutputMeter,			// ASIOChannelControls* in params, fill meter
+	kAsioCanInputMonitor,			// no arguments for kAsioCanXXX selectors
+	kAsioCanTimeInfo,
+	kAsioCanTimeCode,
+	kAsioCanTransport,
+	kAsioCanInputGain,
+	kAsioCanInputMeter,
+	kAsioCanOutputGain,
+	kAsioCanOutputMeter,
+	kAsioOptionalOne,
+	
+	//	DSD support
+	//	The following extensions are required to allow switching
+	//	and control of the DSD subsystem.
+	kAsioSetIoFormat			= 0x23111961,		/* ASIOIoFormat * in params.			*/
+	kAsioGetIoFormat			= 0x23111983,		/* ASIOIoFormat * in params.			*/
+	kAsioCanDoIoFormat			= 0x23112004,		/* ASIOIoFormat * in params.			*/
+	
+	// Extension for drop out detection
+	kAsioCanReportOverload			= 0x24042012,	/* return ASE_SUCCESS if driver can detect and report overloads */
+	
+	kAsioGetInternalBufferSamples	= 0x25042012	/* ASIOInternalBufferInfo * in params. Deliver size of driver internal buffering, return ASE_SUCCESS if supported */
+};
+
+typedef struct ASIOInputMonitor
+{
+	long input;		// this input was set to monitor (or off), -1: all
+	long output;	// suggested output for monitoring the input (if so)
+	long gain;		// suggested gain, ranging 0 - 0x7fffffffL (-inf to +12 dB)
+	ASIOBool state;	// ASIOTrue => on, ASIOFalse => off
+	long pan;		// suggested pan, 0 => all left, 0x7fffffff => right
+} ASIOInputMonitor;
+
+typedef struct ASIOChannelControls
+{
+	long channel;			// on input, channel index
+	ASIOBool isInput;		// on input
+	long gain;				// on input,  ranges 0 thru 0x7fffffff
+	long meter;				// on return, ranges 0 thru 0x7fffffff
+	char future[32];
+} ASIOChannelControls;
+
+typedef struct ASIOTransportParameters
+{
+	long command;		// see enum below
+	ASIOSamples samplePosition;
+	long track;
+	long trackSwitches[16];		// 512 tracks on/off
+	char future[64];
+} ASIOTransportParameters;
+
+enum
+{
+	kTransStart = 1,
+	kTransStop,
+	kTransLocate,		// to samplePosition
+	kTransPunchIn,
+	kTransPunchOut,
+	kTransArmOn,		// track
+	kTransArmOff,		// track
+	kTransMonitorOn,	// track
+	kTransMonitorOff,	// track
+	kTransArm,			// trackSwitches
+	kTransMonitor		// trackSwitches
+};
+
+/*
+// DSD support
+//	Some notes on how to use ASIOIoFormatType.
+//
+//	The caller will fill the format with the request types.
+//	If the board can do the request then it will leave the
+//	values unchanged. If the board does not support the
+//	request then it will change that entry to Invalid (-1)
+//
+//	So to request DSD then
+//
+//	ASIOIoFormat NeedThis={kASIODSDFormat};
+//
+//	if(ASE_SUCCESS != ASIOFuture(kAsioSetIoFormat,&NeedThis) ){
+//		// If the board did not accept one of the parameters then the
+//		// whole call will fail and the failing parameter will
+//		// have had its value changes to -1.
+//	}
+//
+// Note: Switching between the formats need to be done before the "prepared"
+// state (see ASIO 2 documentation) is entered.
+*/
+typedef long int ASIOIoFormatType;
+enum ASIOIoFormatType_e
+{
+	kASIOFormatInvalid = -1,
+	kASIOPCMFormat = 0,
+	kASIODSDFormat = 1,
+};
+
+typedef struct ASIOIoFormat_s
+{
+	ASIOIoFormatType	FormatType;
+	char				future[512-sizeof(ASIOIoFormatType)];
+} ASIOIoFormat;
+
+// Extension for drop detection
+// Note: Refers to buffering that goes beyond the double buffer e.g. used by USB driver designs
+typedef struct ASIOInternalBufferInfo
+{
+	long inputSamples;			// size of driver's internal input buffering which is included in getLatencies
+	long outputSamples;			// size of driver's internal output buffering which is included in getLatencies
+} ASIOInternalBufferInfo;
+
+
+ASIOError ASIOOutputReady(void);
+/* Purpose:
+	  this tells the driver that the host has completed processing
+	  the output buffers. if the data format required by the hardware
+	  differs from the supported asio formats, but the hardware
+	  buffers are DMA buffers, the driver will have to convert
+	  the audio stream data; as the bufferSwitch callback is
+	  usually issued at dma block switch time, the driver will
+	  have to convert the *previous* host buffer, which increases
+	  the output latency by one block.
+	  when the host finds out that ASIOOutputReady() returns
+	  true, it will issue this call whenever it completed
+	  output processing. then the driver can convert the
+	  host data directly to the dma buffer to be played next,
+	  reducing output latency by one block.
+	  another way to look at it is, that the buffer switch is called
+	  in order to pass the *input* stream to the host, so that it can
+	  process the input into the output, and the output stream is passed
+	  to the driver when the host has completed its process.
+	Parameter:
+		None
+	Returns:
+	  only if the above mentioned scenario is given, and a reduction
+	  of output latency can be acheived by this mechanism, should
+	  ASE_OK be returned. otherwise (and usually), ASE_NotPresent
+	  should be returned in order to prevent further calls to this
+	  function. note that the host may want to determine if it is
+	  to use this when the system is not yet fully initialized, so
+	  ASE_OK should always be returned if the mechanism makes sense.	  
+	Notes:
+	  please remeber to adjust ASIOGetLatencies() according to
+	  whether ASIOOutputReady() was ever called or not, if your
+	  driver supports this scenario.
+	  also note that the engine may fail to call ASIO_OutputReady()
+	  in time in overload cases. as already mentioned, bufferSwitch
+      should be called for every block regardless of whether a block
+      could be processed in time.
+*/
+
+// restore old alignment
+#if defined(_MSC_VER) && !defined(__MWERKS__) 
+#pragma pack(pop)
+#elif PRAGMA_ALIGN_SUPPORTED
+#pragma options align = reset
+#endif
+
+#endif
+
diff --git a/include/audio_backend/iasiodrv.h b/include/audio_backend/iasiodrv.h
new file mode 100644
index 0000000..a0adfa4
--- /dev/null
+++ b/include/audio_backend/iasiodrv.h
@@ -0,0 +1,35 @@
+//Steinberg Audio Stream I / O API
+//(c) 1997 - 2013, Steinberg Media Technologies GmbH
+
+#define IEEE754_64FLOAT 1
+#define NATIVE_INT64 1
+#include "asio.h"
+#include <Unknwn.h>
+
+class IASIO : public IUnknown
+{
+public:
+  virtual ASIOBool init(void *sysHandle) = 0;
+  virtual void getDriverName(char *name) = 0;
+  virtual long getDriverVersion() = 0;
+  virtual void getErrorMessage(char *string) = 0;
+  virtual ASIOError start() = 0;
+  virtual ASIOError stop() = 0;
+  virtual ASIOError getChannels(long *numInputChannels, long *numOutputChannels) = 0;
+  virtual ASIOError getLatencies(long *inputLatency, long *outputLatency) = 0;
+  virtual ASIOError getBufferSize(long *minSize, long *maxSize,
+    long *preferredSize, long *granularity) = 0;
+  virtual ASIOError canSampleRate(ASIOSampleRate sampleRate) = 0;
+  virtual ASIOError getSampleRate(ASIOSampleRate *sampleRate) = 0;
+  virtual ASIOError setSampleRate(ASIOSampleRate sampleRate) = 0;
+  virtual ASIOError getClockSources(ASIOClockSource *clocks, long *numSources) = 0;
+  virtual ASIOError setClockSource(long reference) = 0;
+  virtual ASIOError getSamplePosition(ASIOSamples *sPos, ASIOTimeStamp *tStamp) = 0;
+  virtual ASIOError getChannelInfo(ASIOChannelInfo *info) = 0;
+  virtual ASIOError createBuffers(ASIOBufferInfo *bufferInfos, long numChannels,
+    long bufferSize, ASIOCallbacks *callbacks) = 0;
+  virtual ASIOError disposeBuffers() = 0;
+  virtual ASIOError controlPanel() = 0;
+  virtual ASIOError future(long selector, void *opt) = 0;
+  virtual ASIOError outputReady() = 0;
+};
diff --git a/include/cpp/span.hpp b/include/cpp/span.hpp
index bc33365..a6aae56 100644
--- a/include/cpp/span.hpp
+++ b/include/cpp/span.hpp
@@ -114,9 +114,9 @@ inline void contract_violation(const char* msg)
 #define TCB_SPAN_HAVE_DEDUCTION_GUIDES
 #endif
 
-#if defined(TCB_SPAN_HAVE_CPP17) || defined(__cpp_lib_byte)
-#define TCB_SPAN_HAVE_STD_BYTE
-#endif
+//#if defined(TCB_SPAN_HAVE_CPP17) || defined(__cpp_lib_byte)
+//#define TCB_SPAN_HAVE_STD_BYTE
+//#endif
 
 #if defined(TCB_SPAN_HAVE_CPP17) || defined(__cpp_lib_array_constexpr)
 #define TCB_SPAN_HAVE_CONSTEXPR_STD_ARRAY_ETC

From 3c1602dbd8357967f99efbea722c2e2565a1b465 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Mon, 20 May 2019 22:56:57 +0100
Subject: [PATCH 16/97] Implement sample rate accessors

---
 include/audio_backend/__asio_audio_device.h | 29 +++++++++++++++++----
 1 file changed, 24 insertions(+), 5 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 2a09f7f..6b2b70e 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -54,18 +54,21 @@ class audio_device final {
     return _num_outputs;
   }
 
-  using sample_rate_t = int;
+  using sample_rate_t = ASIOSampleRate;
 
   sample_rate_t get_sample_rate() const noexcept {
-    return {};
+    sample_rate_t sample_rate = 0;
+    _asio->getSampleRate(&sample_rate);
+    return sample_rate;
   }
 
   span<const sample_rate_t> get_supported_sample_rates() const noexcept {
-    return {};
+    return _sample_rates;
   }
 
-  bool set_sample_rate(sample_rate_t) {
-    return false;
+  bool set_sample_rate(sample_rate_t sample_rate) {
+    const auto result = _asio->setSampleRate(sample_rate);
+    return result == ASE_OK;
   }
 
   using buffer_size_t = int;
@@ -141,6 +144,21 @@ class audio_device final {
       return;
     }
     _asio->getChannels(&_num_inputs, &_num_outputs);
+
+    initialise_sample_rates();
+  }
+
+  void initialise_sample_rates()
+  {
+    constexpr array<sample_rate_t, 6> common_sample_rates = { 44'100, 48'000, 88'200, 96'000, 176'400, 192'000 };
+    for (const auto sample_rate : common_sample_rates) {
+      if (ASE_OK == _asio->canSampleRate(sample_rate)) {
+        _sample_rates.push_back(sample_rate);
+      }
+    }
+    if (0 == get_sample_rate()) {
+      set_sample_rate(_sample_rates[0]);
+    }
   }
 
   CComPtr<IASIO> _asio;
@@ -148,6 +166,7 @@ class audio_device final {
   device_id_t _id;
   long _num_inputs = 0;
   long _num_outputs = 0;
+  vector<sample_rate_t> _sample_rates;
 };
 
 class audio_device_list : public forward_list<audio_device> {

From 8962a9c5ad1c40262cacf3730a503fe3eb91ec76 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Mon, 20 May 2019 23:03:10 +0100
Subject: [PATCH 17/97] Implement buffer size accessors

---
 include/audio_backend/__asio_audio_device.h | 47 ++++++++++++++++++---
 1 file changed, 41 insertions(+), 6 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 6b2b70e..b9692b3 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -71,18 +71,22 @@ class audio_device final {
     return result == ASE_OK;
   }
 
-  using buffer_size_t = int;
+  using buffer_size_t = long;
 
   buffer_size_t get_buffer_size_frames() const noexcept {
-    return {};
+    return _buffer_size;
   }
 
   span<const buffer_size_t> get_supported_buffer_sizes_frames() const noexcept {
-    return {};
+    return _buffer_sizes;
   }
 
-  bool set_buffer_size_frames(buffer_size_t) {
-    return false;
+  bool set_buffer_size_frames(const buffer_size_t buffer_size) {
+    if (find(begin(_buffer_sizes), end(_buffer_sizes), buffer_size) == end(_buffer_sizes)) {
+      return false;
+    }
+    _buffer_size = buffer_size;
+    return true;
   }
 
   template <typename _SampleType>
@@ -143,14 +147,43 @@ class audio_device final {
     if (!_asio->init(nullptr)) {
       return;
     }
-    _asio->getChannels(&_num_inputs, &_num_outputs);
 
+    initialise_io();
     initialise_sample_rates();
   }
 
+  void initialise_io() {
+    const auto result = _asio->getChannels(&_num_inputs, &_num_outputs);
+
+    if (result != ASE_OK) {
+      return;
+    }
+
+    long min;
+    long max;
+    long granularity;
+    _asio->getBufferSize(&min, &max, &_buffer_size, &granularity);
+
+    if (granularity == -1) {
+      // Buffers are powers of two
+      for (long size = min; size < max; size *= 2) {
+        _buffer_sizes.push_back(size);
+      }
+    }
+    else if (granularity == 0) {
+      _buffer_sizes.push_back(_buffer_size);
+    }
+    else if (granularity > 0) {
+      for (long size = min; size <= max; size += granularity) {
+        _buffer_sizes.push_back(size);
+      }
+    }
+  }
+
   void initialise_sample_rates()
   {
     constexpr array<sample_rate_t, 6> common_sample_rates = { 44'100, 48'000, 88'200, 96'000, 176'400, 192'000 };
+
     for (const auto sample_rate : common_sample_rates) {
       if (ASE_OK == _asio->canSampleRate(sample_rate)) {
         _sample_rates.push_back(sample_rate);
@@ -167,6 +200,8 @@ class audio_device final {
   long _num_inputs = 0;
   long _num_outputs = 0;
   vector<sample_rate_t> _sample_rates;
+  vector<buffer_size_t> _buffer_sizes;
+  buffer_size_t _buffer_size = 0;
 };
 
 class audio_device_list : public forward_list<audio_device> {

From 7f78517b248edf04479492fe611f333f6494e68f Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Mon, 20 May 2019 23:06:00 +0100
Subject: [PATCH 18/97] Add audio_device_exception & _running member

---
 include/audio_backend/__asio_audio_device.h | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index b9692b3..2fd249b 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -19,6 +19,12 @@
 
 _LIBSTDAUDIO_NAMESPACE_BEGIN
 
+struct audio_device_exception : public runtime_error {
+  explicit audio_device_exception(const char* what)
+    : runtime_error(what) {
+  }
+};
+
 // TODO: templatize audio_device as per 6.4 Device Selection API
 class audio_device final {
 public:
@@ -103,15 +109,17 @@ class audio_device final {
   }
 
   bool start() {
+    _running = true;
     return false;
   }
 
   bool stop() {
+    _running = false;
     return false;
   }
 
   bool is_running() const noexcept {
-    return false;
+    return _running;
   }
 
   void wait() const {
@@ -135,6 +143,9 @@ class audio_device final {
 
   template <typename _CallbackType>
   void connect(_CallbackType) {
+    if (_running) {
+      throw audio_device_exception("cannot connect to running audio_device");
+    }
     assert(false);
   }
 
@@ -142,7 +153,7 @@ class audio_device final {
   void initialise_asio(CLSID class_id) {
     const auto result = CoCreateInstance(class_id, nullptr, CLSCTX_INPROC_SERVER, class_id, reinterpret_cast<void**>(&_asio));
     if (result) {
-      throw runtime_error("Failed to open ASIO driver: 0x" + result);
+      throw audio_device_exception("Failed to open ASIO driver: 0x" + result);
     }
     if (!_asio->init(nullptr)) {
       return;
@@ -202,6 +213,7 @@ class audio_device final {
   vector<sample_rate_t> _sample_rates;
   vector<buffer_size_t> _buffer_sizes;
   buffer_size_t _buffer_size = 0;
+  bool _running = false;
 };
 
 class audio_device_list : public forward_list<audio_device> {

From 9b4adbb14eb6b76f85a4122eca3320ae89a94915 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Mon, 20 May 2019 23:11:13 +0100
Subject: [PATCH 19/97] Retrieve the ASIO driver's sample type

ASIO drivers use different underlying sample types so that the driver
can specify an efficient native format. P1386R1 has no mechanism to
query native sample type.
---
 include/audio_backend/__asio_audio_device.h | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 2fd249b..a655396 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -189,6 +189,10 @@ class audio_device final {
         _buffer_sizes.push_back(size);
       }
     }
+
+    ASIOChannelInfo info{0, _num_inputs > 0};
+    _asio->getChannelInfo(&info);
+    _sample_type = info.type;
   }
 
   void initialise_sample_rates()
@@ -214,6 +218,8 @@ class audio_device final {
   vector<buffer_size_t> _buffer_sizes;
   buffer_size_t _buffer_size = 0;
   bool _running = false;
+
+  ASIOSampleType _sample_type;
 };
 
 class audio_device_list : public forward_list<audio_device> {

From 966905ac1840eb998cb422656eb2b6cb33141d37 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Mon, 20 May 2019 23:16:34 +0100
Subject: [PATCH 20/97] Set the callback for the default (float) sample type

---
 include/audio_backend/__asio_audio_device.h | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index a655396..0564617 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -12,6 +12,7 @@
 #include <cassert>
 #include <forward_list>
 #include <vector>
+#include <functional>
 
 #define WIN32_LEAN_AND_MEAN
 #include <Windows.h>
@@ -19,6 +20,8 @@
 
 _LIBSTDAUDIO_NAMESPACE_BEGIN
 
+using __asio_common_sample_type = float;
+
 struct audio_device_exception : public runtime_error {
   explicit audio_device_exception(const char* what)
     : runtime_error(what) {
@@ -97,7 +100,7 @@ class audio_device final {
 
   template <typename _SampleType>
   constexpr bool supports_sample_type() const noexcept {
-    return false;
+    return is_same_v<_SampleType, __asio_common_sample_type>;
   }
 
   constexpr bool can_connect() const noexcept {
@@ -141,12 +144,13 @@ class audio_device final {
     assert(false);
   }
 
-  template <typename _CallbackType>
-  void connect(_CallbackType) {
+  template <typename _CallbackType,
+            typename = enable_if_t<is_nothrow_invocable_v<_CallbackType, audio_device&, audio_device_io<__asio_common_sample_type >&>> >
+  void connect(_CallbackType callback) {
     if (_running) {
       throw audio_device_exception("cannot connect to running audio_device");
     }
-    assert(false);
+    _user_callback = move(callback);
   }
 
 private:
@@ -220,6 +224,8 @@ class audio_device final {
   bool _running = false;
 
   ASIOSampleType _sample_type;
+  using __asio_callback_t = function<void(audio_device&, audio_device_io<__asio_common_sample_type>&)>;
+  __asio_callback_t _user_callback;
 };
 
 class audio_device_list : public forward_list<audio_device> {

From 5e19c0e22a03bc906c4f317724a453159cf7daae Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Mon, 20 May 2019 23:23:03 +0100
Subject: [PATCH 21/97] Implement the ASIO callbacks

---
 include/audio_backend/__asio_audio_device.h | 84 ++++++++++++++++++++-
 1 file changed, 80 insertions(+), 4 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 0564617..b2ac8aa 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -39,6 +39,11 @@ class audio_device final {
     initialise_asio(class_id);
   }
 
+  ~audio_device() {
+    stop();
+    _asio->disposeBuffers();
+  }
+
   string_view name() const noexcept {
     return _name;
   }
@@ -112,13 +117,17 @@ class audio_device final {
   }
 
   bool start() {
-    _running = true;
-    return false;
+    _instance = this;
+    const auto result = _asio->start();
+    _running = result == ASE_OK;
+    return _running;
   }
 
   bool stop() {
+    const auto result = _asio->stop();
     _running = false;
-    return false;
+    _instance = nullptr;
+    return result == ASE_OK;
   }
 
   bool is_running() const noexcept {
@@ -151,6 +160,20 @@ class audio_device final {
       throw audio_device_exception("cannot connect to running audio_device");
     }
     _user_callback = move(callback);
+
+    for (int i = 0; i < _num_inputs; ++i) {
+      _asio_buffers.emplace_back(ASIOBufferInfo{true, i});
+    }
+    for (int i = 0; i < _num_outputs; ++i) {
+      _asio_buffers.emplace_back(ASIOBufferInfo{false, i});
+    }
+
+    const long num_channels = _num_inputs + _num_outputs;
+    const auto result = _asio->createBuffers(_asio_buffers.data(), num_channels, _buffer_size, &_asio_callbacks);
+
+    if (result != ASE_OK) {
+      throw audio_device_exception("failed to create ASIO buffers: " + result);
+    }
   }
 
 private:
@@ -163,10 +186,18 @@ class audio_device final {
       return;
     }
 
+    initialise_callbacks();
     initialise_io();
     initialise_sample_rates();
   }
 
+  void initialise_callbacks() {
+    _asio_callbacks.bufferSwitch = &audio_device::buffer_switch;
+    _asio_callbacks.bufferSwitchTimeInfo = &audio_device::buffer_switch_time_info;
+    _asio_callbacks.asioMessage = &audio_device::asio_message;
+    _asio_callbacks.sampleRateDidChange = &audio_device::sample_rate_changed;
+  }
+
   void initialise_io() {
     const auto result = _asio->getChannels(&_num_inputs, &_num_outputs);
 
@@ -213,6 +244,29 @@ class audio_device final {
     }
   }
 
+  static void buffer_switch(long /*index*/, ASIOBool /*direct_process*/) {}
+
+
+  static void sample_rate_changed(ASIOSampleRate /*sample_rate*/) {}
+
+  static long asio_message(long selector, long /*value*/, void* /*message*/, double* /*opt*/) {
+    switch (selector)
+    {
+    case kAsioSupportsTimeInfo: return ASIOTrue;
+    case kAsioEngineVersion: return 2;
+    case kAsioSelectorSupported: return ASIOFalse;
+    default: return false;
+    }
+  }
+
+  static ASIOTime* buffer_switch_time_info (ASIOTime* params, long index, ASIOBool /*direct_process*/) {
+    return _instance->on_buffer_switch(params, index);
+  }
+
+  static ASIOTime* on_buffer_switch(ASIOTime* /*params*/, long /*double_buffer_index*/) {
+    return nullptr;
+  }
+
   CComPtr<IASIO> _asio;
   const string _name;
   device_id_t _id;
@@ -226,8 +280,14 @@ class audio_device final {
   ASIOSampleType _sample_type;
   using __asio_callback_t = function<void(audio_device&, audio_device_io<__asio_common_sample_type>&)>;
   __asio_callback_t _user_callback;
+
+  vector< ASIOBufferInfo> _asio_buffers;
+  static audio_device* _instance;
+  ASIOCallbacks _asio_callbacks;
 };
 
+audio_device* audio_device::_instance = nullptr;
+
 class audio_device_list : public forward_list<audio_device> {
 };
 
@@ -302,7 +362,11 @@ class __asio_devices {
   }
 
   optional<audio_device> default_output() {
-    return {};
+    auto devices = outputs();
+    if (devices.empty()) {
+      return {};
+    }
+    return *devices.begin();
   }
 
   audio_device_list inputs() {
@@ -330,6 +394,10 @@ class __asio_devices {
 
     int index = 0;
     for (const auto& name : asio_reg.subkeys()) {
+
+      if (is_excluded(name)) {
+        continue;
+      }
       const auto key = asio_reg.subkey(name);
       const auto value = key.value("CLSID");
 
@@ -343,6 +411,14 @@ class __asio_devices {
     }
     return devices;
   }
+
+  bool is_excluded(string_view name)
+  {
+    if (name == "Realtek ASIO") {
+      return true;
+    }
+    return false;
+  }
 };
 
 _LIBSTDAUDIO_NAMESPACE_END

From 8d71eb6ed7dd9f0c6e53adcfccc23c2e555e9b22 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Mon, 20 May 2019 23:51:49 +0100
Subject: [PATCH 22/97] Respond to ASIO buffer_switch message with updated
 timestamp & position

---
 CMakeLists.txt                              |  4 ++
 include/audio_backend/__asio_audio_device.h | 68 ++++++++++++++-------
 2 files changed, 49 insertions(+), 23 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 20c151c..c3cf4d4 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -18,6 +18,10 @@ if (APPLE)
     set(CMAKE_EXE_LINKER_FLAGS "-framework CoreAudio")
 endif ()
 
+if (MSVC)
+    set(CMAKE_EXE_LINKER_FLAGS "winmm.lib")
+endif ()
+
 include_directories(include)
 
 add_executable(white_noise examples/white_noise.cpp)
diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index b2ac8aa..08aec68 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -109,7 +109,7 @@ class audio_device final {
   }
 
   constexpr bool can_connect() const noexcept {
-    return false;
+    return true;
   }
 
   constexpr bool can_process() const noexcept {
@@ -118,6 +118,7 @@ class audio_device final {
 
   bool start() {
     _instance = this;
+    _sample_position = 0;
     const auto result = _asio->start();
     _running = result == ASE_OK;
     return _running;
@@ -154,26 +155,14 @@ class audio_device final {
   }
 
   template <typename _CallbackType,
-            typename = enable_if_t<is_nothrow_invocable_v<_CallbackType, audio_device&, audio_device_io<__asio_common_sample_type >&>> >
+            typename = enable_if_t<is_nothrow_invocable_v<_CallbackType, audio_device&, audio_device_io<float>&>> >
   void connect(_CallbackType callback) {
     if (_running) {
       throw audio_device_exception("cannot connect to running audio_device");
     }
     _user_callback = move(callback);
 
-    for (int i = 0; i < _num_inputs; ++i) {
-      _asio_buffers.emplace_back(ASIOBufferInfo{true, i});
-    }
-    for (int i = 0; i < _num_outputs; ++i) {
-      _asio_buffers.emplace_back(ASIOBufferInfo{false, i});
-    }
-
-    const long num_channels = _num_inputs + _num_outputs;
-    const auto result = _asio->createBuffers(_asio_buffers.data(), num_channels, _buffer_size, &_asio_callbacks);
-
-    if (result != ASE_OK) {
-      throw audio_device_exception("failed to create ASIO buffers: " + result);
-    }
+    initialise_buffers();
   }
 
 private:
@@ -244,6 +233,28 @@ class audio_device final {
     }
   }
 
+  void initialise_buffers() {
+
+    for (int i = 0; i < _num_inputs; ++i) {
+      _asio_buffers.emplace_back(ASIOBufferInfo{ true, i });
+    }
+    for (int i = 0; i < _num_outputs; ++i) {
+      _asio_buffers.emplace_back(ASIOBufferInfo{ false, i });
+    }
+
+    const long num_channels = _num_inputs + _num_outputs;
+    const auto result = _asio->createBuffers(_asio_buffers.data(), num_channels, _buffer_size, &_asio_callbacks);
+
+    if (result != ASE_OK) {
+      throw audio_device_exception("failed to create ASIO buffers: " + result);
+    }
+
+    _input_samples.resize(_num_inputs * _buffer_size);
+    _output_samples.resize(_num_outputs * _buffer_size);
+    _io.input_buffer = { _input_samples.data(), _input_samples.size(), size_t(_num_inputs) };
+    _io.output_buffer = { _output_samples.data(), _output_samples.size(), size_t(_num_outputs) };
+  }
+
   static void buffer_switch(long /*index*/, ASIOBool /*direct_process*/) {}
 
 
@@ -255,7 +266,7 @@ class audio_device final {
     case kAsioSupportsTimeInfo: return ASIOTrue;
     case kAsioEngineVersion: return 2;
     case kAsioSelectorSupported: return ASIOFalse;
-    default: return false;
+    default: return ASIOFalse;
     }
   }
 
@@ -263,8 +274,13 @@ class audio_device final {
     return _instance->on_buffer_switch(params, index);
   }
 
-  static ASIOTime* on_buffer_switch(ASIOTime* /*params*/, long /*double_buffer_index*/) {
-    return nullptr;
+  ASIOTime* on_buffer_switch(ASIOTime* time, long /*index*/) {
+
+    time->timeInfo.flags = kSystemTimeValid | kSamplePositionValid;
+    time->timeInfo.samplePosition = _sample_position;
+    _sample_position += _buffer_size;
+    time->timeInfo.systemTime = timeGetTime() * 1'000'000;
+    return time;
   }
 
   CComPtr<IASIO> _asio;
@@ -278,10 +294,16 @@ class audio_device final {
   bool _running = false;
 
   ASIOSampleType _sample_type;
+  ASIOSamples _sample_position = 0;
+
   using __asio_callback_t = function<void(audio_device&, audio_device_io<__asio_common_sample_type>&)>;
   __asio_callback_t _user_callback;
+  audio_device_io<__asio_common_sample_type> _io;
+  vector<float> _input_samples;
+  vector<float> _output_samples;
+
 
-  vector< ASIOBufferInfo> _asio_buffers;
+  vector<ASIOBufferInfo> _asio_buffers;
   static audio_device* _instance;
   ASIOCallbacks _asio_callbacks;
 };
@@ -329,7 +351,7 @@ class __reg_key_reader final
 
   __reg_key_reader subkey(const string& name)
   {
-    return {_key, name};
+    return { _key, name};
   }
 
   string value(const char* name) const {
@@ -399,14 +421,14 @@ class __asio_devices {
         continue;
       }
       const auto key = asio_reg.subkey(name);
-      const auto value = key.value("CLSID");
+      const auto clsid = key.value("CLSID");
 
       CLSID class_id;
-      CLSIDFromString(CComBSTR(value.c_str()), &class_id);
+      CLSIDFromString(CComBSTR(clsid.c_str()), &class_id);
 
       auto device = audio_device{index++, name, class_id};
       if (condition(device)) {
-        devices.emplace_front(move(device));
+        devices.push_front(move(device));
       }
     }
     return devices;

From daca8c39207ed6f516d5c61c53c989785ddf7b29 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Tue, 21 May 2019 00:02:04 +0100
Subject: [PATCH 23/97] Fill output buffers

---
 include/audio_backend/__asio_audio_device.h | 28 +++++++++++++++++++--
 1 file changed, 26 insertions(+), 2 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 08aec68..3c29e40 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -253,6 +253,25 @@ class audio_device final {
     _output_samples.resize(_num_outputs * _buffer_size);
     _io.input_buffer = { _input_samples.data(), _input_samples.size(), size_t(_num_inputs) };
     _io.output_buffer = { _output_samples.data(), _output_samples.size(), size_t(_num_outputs) };
+
+
+    switch (_sample_type)
+    {
+    case ASIOSTInt32LSB:
+    {
+      _fill_output_buffers = [&](long index) {
+
+        auto& out = *_io.output_buffer;
+        for (int frame = 0; frame < out.size_frames(); ++frame) {
+          for (int channel = 0; channel < _num_outputs; ++channel) {
+            const auto buffer = static_cast<int32_t*>(_asio_buffers[_num_inputs + channel].buffers[index]);
+            const auto sample = static_cast<int32_t>(INT32_MAX * out(frame, channel));
+            buffer[frame] = sample;
+          }
+        }
+      };
+    }
+    }
   }
 
   static void buffer_switch(long /*index*/, ASIOBool /*direct_process*/) {}
@@ -274,7 +293,10 @@ class audio_device final {
     return _instance->on_buffer_switch(params, index);
   }
 
-  ASIOTime* on_buffer_switch(ASIOTime* time, long /*index*/) {
+  ASIOTime* on_buffer_switch(ASIOTime* time, long index) {
+
+    _user_callback(*this, _io);
+    _fill_output_buffers(index);
 
     time->timeInfo.flags = kSystemTimeValid | kSamplePositionValid;
     time->timeInfo.samplePosition = _sample_position;
@@ -296,12 +318,14 @@ class audio_device final {
   ASIOSampleType _sample_type;
   ASIOSamples _sample_position = 0;
 
-  using __asio_callback_t = function<void(audio_device&, audio_device_io<__asio_common_sample_type>&)>;
+  using __asio_callback_t = function<void(audio_device&, audio_device_io<float>&)>;
   __asio_callback_t _user_callback;
   audio_device_io<__asio_common_sample_type> _io;
   vector<float> _input_samples;
   vector<float> _output_samples;
 
+  using fill_buffers = function<void(long index)>;
+  fill_buffers _fill_output_buffers;
 
   vector<ASIOBufferInfo> _asio_buffers;
   static audio_device* _instance;

From 618c65147d3cd739c7dea480a643ff14949c56c0 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Tue, 21 May 2019 00:10:51 +0100
Subject: [PATCH 24/97] Fill input buffers

---
 include/audio_backend/__asio_audio_device.h | 40 ++++++++++++++++-----
 1 file changed, 32 insertions(+), 8 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 3c29e40..3a0c0d6 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -125,6 +125,7 @@ class audio_device final {
   }
 
   bool stop() {
+    //TODO: fade out to prevent audio clicks on stop
     const auto result = _asio->stop();
     _running = false;
     _instance = nullptr;
@@ -251,16 +252,19 @@ class audio_device final {
 
     _input_samples.resize(_num_inputs * _buffer_size);
     _output_samples.resize(_num_outputs * _buffer_size);
-    _io.input_buffer = { _input_samples.data(), _input_samples.size(), size_t(_num_inputs) };
-    _io.output_buffer = { _output_samples.data(), _output_samples.size(), size_t(_num_outputs) };
+    _io.input_buffer = {_input_samples.data(), _input_samples.size(), size_t(_num_inputs)};
+    _io.output_buffer = {_output_samples.data(), _output_samples.size(), size_t(_num_outputs)};
 
+    initialise_buffer_fillers();
+  }
+
+  void initialise_buffer_fillers() {
 
     switch (_sample_type)
     {
     case ASIOSTInt32LSB:
     {
       _fill_output_buffers = [&](long index) {
-
         auto& out = *_io.output_buffer;
         for (int frame = 0; frame < out.size_frames(); ++frame) {
           for (int channel = 0; channel < _num_outputs; ++channel) {
@@ -270,13 +274,27 @@ class audio_device final {
           }
         }
       };
+
+      _fill_input_buffers = [&](long index) {
+        auto& in = *_io.input_buffer;
+        for (int frame = 0; frame < in.size_frames(); ++frame) {
+          for (int channel = 0; channel < _num_outputs; ++channel) {
+            const auto buffer = static_cast<int32_t*>(_asio_buffers[channel].buffers[index]);
+            const auto sample = static_cast<float>(buffer[frame]) / INT32_MAX;
+            in(frame, channel) = sample;
+          }
+        }
+      };
+
+      break;
     }
+    default: //TODO: Implement other sample types
+      throw audio_device_exception("ASIO native sample type not supported: " + _sample_type);
     }
   }
 
   static void buffer_switch(long /*index*/, ASIOBool /*direct_process*/) {}
 
-
   static void sample_rate_changed(ASIOSampleRate /*sample_rate*/) {}
 
   static long asio_message(long selector, long /*value*/, void* /*message*/, double* /*opt*/) {
@@ -289,12 +307,13 @@ class audio_device final {
     }
   }
 
-  static ASIOTime* buffer_switch_time_info (ASIOTime* params, long index, ASIOBool /*direct_process*/) {
-    return _instance->on_buffer_switch(params, index);
+  static ASIOTime* buffer_switch_time_info (ASIOTime* time, long index, ASIOBool /*direct_process*/) {
+    return _instance->on_buffer_switch(time, index);
   }
 
   ASIOTime* on_buffer_switch(ASIOTime* time, long index) {
 
+    _fill_input_buffers(index);
     _user_callback(*this, _io);
     _fill_output_buffers(index);
 
@@ -325,6 +344,7 @@ class audio_device final {
   vector<float> _output_samples;
 
   using fill_buffers = function<void(long index)>;
+  fill_buffers _fill_input_buffers;
   fill_buffers _fill_output_buffers;
 
   vector<ASIOBufferInfo> _asio_buffers;
@@ -375,7 +395,7 @@ class __reg_key_reader final
 
   __reg_key_reader subkey(const string& name)
   {
-    return { _key, name};
+    return {_key, name};
   }
 
   string value(const char* name) const {
@@ -404,7 +424,11 @@ class __asio_devices {
   }
 
   optional<audio_device> default_input() {
-    return {};
+    auto devices = inputs();
+    if (devices.empty()) {
+      return {};
+    }
+    return *devices.begin();
   }
 
   optional<audio_device> default_output() {

From f254785387bbf5ccf77e93faf803d255a626d264 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Wed, 22 May 2019 09:11:11 +0100
Subject: [PATCH 25/97] Make audio devices half-duplex

---
 include/audio_backend/__asio_audio_device.h | 91 ++++++++++++++-------
 1 file changed, 62 insertions(+), 29 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 3a0c0d6..eca6d82 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -28,15 +28,17 @@ struct audio_device_exception : public runtime_error {
   }
 };
 
+enum class audio_direction {in, out, full_duplex};
+
 // TODO: templatize audio_device as per 6.4 Device Selection API
 class audio_device final {
 public:
   using device_id_t = int;
 
-  explicit audio_device(device_id_t id, string name, CLSID class_id)
+  explicit audio_device(device_id_t id, string name, CLSID class_id, audio_direction direction)
     : _name(name), _id(id)
   {
-    initialise_asio(class_id);
+    initialise_asio(class_id, direction);
   }
 
   ~audio_device() {
@@ -167,7 +169,7 @@ class audio_device final {
   }
 
 private:
-  void initialise_asio(CLSID class_id) {
+  void initialise_asio(const CLSID class_id, const audio_direction direction) {
     const auto result = CoCreateInstance(class_id, nullptr, CLSCTX_INPROC_SERVER, class_id, reinterpret_cast<void**>(&_asio));
     if (result) {
       throw audio_device_exception("Failed to open ASIO driver: 0x" + result);
@@ -177,7 +179,7 @@ class audio_device final {
     }
 
     initialise_callbacks();
-    initialise_io();
+    initialise_io(direction);
     initialise_sample_rates();
   }
 
@@ -188,13 +190,18 @@ class audio_device final {
     _asio_callbacks.sampleRateDidChange = &audio_device::sample_rate_changed;
   }
 
-  void initialise_io() {
+  void initialise_io(const audio_direction direction) {
     const auto result = _asio->getChannels(&_num_inputs, &_num_outputs);
 
     if (result != ASE_OK) {
       return;
     }
 
+    switch (direction) {
+    case audio_direction::in: _num_outputs = 0; break;
+    case audio_direction::out: _num_inputs = 0; break;
+    }
+
     long min;
     long max;
     long granularity;
@@ -255,37 +262,59 @@ class audio_device final {
     _io.input_buffer = {_input_samples.data(), _input_samples.size(), size_t(_num_inputs)};
     _io.output_buffer = {_output_samples.data(), _output_samples.size(), size_t(_num_outputs)};
 
-    initialise_buffer_fillers();
+    initialise_input_buffer_fillers();
+    initialise_output_buffer_fillers();
   }
 
-  void initialise_buffer_fillers() {
+  void initialise_input_buffer_fillers() {
+
+    if (!is_input()) {
+      _fill_input_buffers = [](long) {};
+      return;
+    }
 
     switch (_sample_type)
     {
     case ASIOSTInt32LSB:
     {
-      _fill_output_buffers = [&](long index) {
-        auto& out = *_io.output_buffer;
-        for (int frame = 0; frame < out.size_frames(); ++frame) {
-          for (int channel = 0; channel < _num_outputs; ++channel) {
-            const auto buffer = static_cast<int32_t*>(_asio_buffers[_num_inputs + channel].buffers[index]);
-            const auto sample = static_cast<int32_t>(INT32_MAX * out(frame, channel));
-            buffer[frame] = sample;
-          }
-        }
-      };
-
       _fill_input_buffers = [&](long index) {
         auto& in = *_io.input_buffer;
         for (int frame = 0; frame < in.size_frames(); ++frame) {
-          for (int channel = 0; channel < _num_outputs; ++channel) {
+          for (int channel = 0; channel < _num_inputs; ++channel) {
             const auto buffer = static_cast<int32_t*>(_asio_buffers[channel].buffers[index]);
             const auto sample = static_cast<float>(buffer[frame]) / INT32_MAX;
             in(frame, channel) = sample;
           }
         }
       };
+      break;
+    }
+    default: //TODO: Implement other sample types
+      throw audio_device_exception("ASIO native sample type not supported: " + _sample_type);
+    }
+  }
 
+  void initialise_output_buffer_fillers() {
+
+    if (!is_output()) {
+      _fill_output_buffers = [](long) {};
+      return;
+    }
+
+    switch (_sample_type)
+    {
+    case ASIOSTInt32LSB:
+    {
+        _fill_output_buffers = [&](long index) {
+          auto& out = *_io.output_buffer;
+          for (int frame = 0; frame < out.size_frames(); ++frame) {
+            for (int channel = 0; channel < _num_outputs; ++channel) {
+              const auto buffer = static_cast<int32_t*>(_asio_buffers[_num_inputs + channel].buffers[index]);
+              const auto sample = static_cast<int32_t>(INT32_MAX * out(frame, channel));
+              buffer[frame] = sample;
+            }
+          }
+        };
       break;
     }
     default: //TODO: Implement other sample types
@@ -440,15 +469,11 @@ class __asio_devices {
   }
 
   audio_device_list inputs() {
-    return enumerate([](const audio_device& device) {
-      return device.is_input();
-    });
+    return enumerate(audio_direction::in);
   }
 
   audio_device_list outputs() {
-    return enumerate([](const audio_device& device) {
-      return device.is_output();
-    });
+    return enumerate(audio_direction::out);
   }
 
 private:
@@ -456,8 +481,7 @@ class __asio_devices {
     CoInitialize(nullptr);
   }
 
-  template <typename Condition>
-  audio_device_list enumerate(Condition condition) {
+  audio_device_list enumerate(audio_direction direction) {
     audio_device_list devices;
 
     __reg_key_reader asio_reg(HKEY_LOCAL_MACHINE, "software\\asio");
@@ -474,14 +498,23 @@ class __asio_devices {
       CLSID class_id;
       CLSIDFromString(CComBSTR(clsid.c_str()), &class_id);
 
-      auto device = audio_device{index++, name, class_id};
-      if (condition(device)) {
+      auto device = audio_device{index++, name, class_id, direction};
+      if (is_required(device, direction)) {
         devices.push_front(move(device));
       }
     }
     return devices;
   }
 
+  static bool is_required(const audio_device& device, const audio_direction direction) {
+    switch (direction) {
+    case audio_direction::in: return device.is_input();
+    case audio_direction::out: return device.is_output();
+    case audio_direction::full_duplex: return device.is_input() && device.is_output();
+    default: return false;
+    };
+  }
+
   bool is_excluded(string_view name)
   {
     if (name == "Realtek ASIO") {

From 66dffedc07c729cdd1e2eefcd9cad7b0b66d2512 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Mon, 27 May 2019 20:58:46 +0100
Subject: [PATCH 26/97] Loop through samples in channel order first when
 converting

ASIO buffers are contiguous for each channel but there is no
guarantee of locality between channels. It makes sense to iterate
through the contiguous samples in the inner loop. This should minimize
cache misses.
---
 include/audio_backend/__asio_audio_device.h | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index eca6d82..b9f41f8 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -279,9 +279,9 @@ class audio_device final {
     {
       _fill_input_buffers = [&](long index) {
         auto& in = *_io.input_buffer;
-        for (int frame = 0; frame < in.size_frames(); ++frame) {
-          for (int channel = 0; channel < _num_inputs; ++channel) {
-            const auto buffer = static_cast<int32_t*>(_asio_buffers[channel].buffers[index]);
+        for (int channel = 0; channel < _num_inputs; ++channel) {
+          const auto buffer = static_cast<int32_t*>(_asio_buffers[channel].buffers[index]);
+          for (int frame = 0; frame < in.size_frames(); ++frame) {
             const auto sample = static_cast<float>(buffer[frame]) / INT32_MAX;
             in(frame, channel) = sample;
           }
@@ -307,9 +307,9 @@ class audio_device final {
     {
         _fill_output_buffers = [&](long index) {
           auto& out = *_io.output_buffer;
-          for (int frame = 0; frame < out.size_frames(); ++frame) {
-            for (int channel = 0; channel < _num_outputs; ++channel) {
-              const auto buffer = static_cast<int32_t*>(_asio_buffers[_num_inputs + channel].buffers[index]);
+          for (int channel = 0; channel < _num_outputs; ++channel) {
+            const auto buffer = static_cast<int32_t*>(_asio_buffers[_num_inputs + channel].buffers[index]);
+            for (int frame = 0; frame < out.size_frames(); ++frame) {
               const auto sample = static_cast<int32_t>(INT32_MAX * out(frame, channel));
               buffer[frame] = sample;
             }

From 89246a5fba6f37fbc22f99fca764882d4e95d060 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sun, 2 Jun 2019 13:40:55 +0100
Subject: [PATCH 27/97] Use C++ casts instead of function-style casts

---
 examples/melody.cpp                         | 6 +++---
 examples/sine_wave.cpp                      | 6 +++---
 include/audio_backend/__asio_audio_device.h | 4 ++--
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/examples/melody.cpp b/examples/melody.cpp
index 4783c17..68fbf2d 100644
--- a/examples/melody.cpp
+++ b/examples/melody.cpp
@@ -26,7 +26,7 @@ constexpr float bpm = 260.0;
 
 float note_to_frequency_hz(int note) {
   constexpr float pitch_standard_hz = 440.0f;
-  return pitch_standard_hz * std::pow(2.0f, float(note - 69) / 12.0f);
+  return pitch_standard_hz * std::pow(2.0f, static_cast<float>(note - 69) / 12.0f);
 }
 
 std::atomic<bool> stop = false;
@@ -48,7 +48,7 @@ struct synthesiser {
     }
 
     const auto next_sample = std::copysign(0.1f, std::sin(_phase));
-    _phase = std::fmod(_phase + _delta, 2.0f * float(M_PI));
+    _phase = std::fmod(_phase + _delta, 2.0f * static_cast<float>(M_PI));
     return next_sample;
   }
 
@@ -80,7 +80,7 @@ int main() {
     return 1;
 
   auto synth = synthesiser();
-  synth.set_sample_rate(float(device->get_sample_rate()));
+  synth.set_sample_rate(static_cast<float>(device->get_sample_rate()));
 
   device->connect([=](audio_device&, audio_device_io<float>& io) mutable noexcept {
     if (!io.output_buffer.has_value())
diff --git a/examples/sine_wave.cpp b/examples/sine_wave.cpp
index db49877..1789d40 100644
--- a/examples/sine_wave.cpp
+++ b/examples/sine_wave.cpp
@@ -20,8 +20,8 @@ int main() {
   if (!device)
     return 1;
 
-  const float frequency_hz = 440.0f;
-  const float delta = 2.0f * frequency_hz * float(M_PI / device->get_sample_rate());
+  constexpr float frequency_hz = 440.0f;
+  const float delta = 2.0f * frequency_hz * static_cast<float>(M_PI / device->get_sample_rate());
   float phase = 0;
 
   device->connect([=](audio_device&, audio_device_io<float>& io) mutable noexcept {
@@ -32,7 +32,7 @@ int main() {
 
     for (int frame = 0; frame < out.size_frames(); ++frame) {
       const float next_sample = std::sin(phase);
-      phase = std::fmod(phase + delta, 2.0f * float(M_PI));
+      phase = std::fmod(phase + delta, 2.0f * static_cast<float>(M_PI));
 
       for (int channel = 0; channel < out.size_channels(); ++channel)
         out(frame, channel) = 0.2f * next_sample;
diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index b9f41f8..a474586 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -259,8 +259,8 @@ class audio_device final {
 
     _input_samples.resize(_num_inputs * _buffer_size);
     _output_samples.resize(_num_outputs * _buffer_size);
-    _io.input_buffer = {_input_samples.data(), _input_samples.size(), size_t(_num_inputs)};
-    _io.output_buffer = {_output_samples.data(), _output_samples.size(), size_t(_num_outputs)};
+    _io.input_buffer = {_input_samples.data(), _input_samples.size(), static_cast<size_t>(_num_inputs)};
+    _io.output_buffer = {_output_samples.data(), _output_samples.size(), static_cast<size_t>(_num_outputs)};
 
     initialise_input_buffer_fillers();
     initialise_output_buffer_fillers();

From 38e5b6720ba65972f0d149728e1eb7d2d2b3905d Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sun, 2 Jun 2019 13:57:54 +0100
Subject: [PATCH 28/97] Use const methods

---
 include/audio_backend/__asio_audio_device.h | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index a474586..044c463 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -422,8 +422,7 @@ class __reg_key_reader final
     return keys;
   }
 
-  __reg_key_reader subkey(const string& name)
-  {
+  __reg_key_reader subkey(const string& name) const {
     return {_key, name};
   }
 
@@ -452,7 +451,7 @@ class __asio_devices {
     CoUninitialize();
   }
 
-  optional<audio_device> default_input() {
+  optional<audio_device> default_input() const {
     auto devices = inputs();
     if (devices.empty()) {
       return {};
@@ -460,7 +459,7 @@ class __asio_devices {
     return *devices.begin();
   }
 
-  optional<audio_device> default_output() {
+  optional<audio_device> default_output() const {
     auto devices = outputs();
     if (devices.empty()) {
       return {};
@@ -468,11 +467,11 @@ class __asio_devices {
     return *devices.begin();
   }
 
-  audio_device_list inputs() {
+  audio_device_list inputs() const {
     return enumerate(audio_direction::in);
   }
 
-  audio_device_list outputs() {
+  audio_device_list outputs() const {
     return enumerate(audio_direction::out);
   }
 
@@ -481,7 +480,7 @@ class __asio_devices {
     CoInitialize(nullptr);
   }
 
-  audio_device_list enumerate(audio_direction direction) {
+  audio_device_list enumerate(audio_direction direction) const {
     audio_device_list devices;
 
     __reg_key_reader asio_reg(HKEY_LOCAL_MACHINE, "software\\asio");
@@ -515,8 +514,7 @@ class __asio_devices {
     };
   }
 
-  bool is_excluded(string_view name)
-  {
+  bool is_excluded(string_view name) const {
     if (name == "Realtek ASIO") {
       return true;
     }

From 4a1b58f23dc751caf345a294627b7c81bf50614a Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sun, 2 Jun 2019 14:11:18 +0100
Subject: [PATCH 29/97] Add comment explaining why Realtek ASIO drivers are
 excluded

---
 include/audio_backend/__asio_audio_device.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 044c463..120e869 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -516,6 +516,8 @@ class __asio_devices {
 
   bool is_excluded(string_view name) const {
     if (name == "Realtek ASIO") {
+      // Realtek ASIO drivers require features that are not implemented yet,
+      // namely using 24-bit packed samples & non-timestamped buffer switch callbacks
       return true;
     }
     return false;

From 415b665f56ef56a569ab64a5d3aabbc21737fa34 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sun, 2 Jun 2019 14:14:36 +0100
Subject: [PATCH 30/97] Remove C-style comments from header

---
 include/audio_backend/__asio_audio_device.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 120e869..d36551a 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -322,11 +322,11 @@ class audio_device final {
     }
   }
 
-  static void buffer_switch(long /*index*/, ASIOBool /*direct_process*/) {}
+  static void buffer_switch(long, ASIOBool) {}
 
-  static void sample_rate_changed(ASIOSampleRate /*sample_rate*/) {}
+  static void sample_rate_changed(ASIOSampleRate) {}
 
-  static long asio_message(long selector, long /*value*/, void* /*message*/, double* /*opt*/) {
+  static long asio_message(long selector, long, void*, double*) {
     switch (selector)
     {
     case kAsioSupportsTimeInfo: return ASIOTrue;
@@ -336,7 +336,7 @@ class audio_device final {
     }
   }
 
-  static ASIOTime* buffer_switch_time_info (ASIOTime* time, long index, ASIOBool /*direct_process*/) {
+  static ASIOTime* buffer_switch_time_info (ASIOTime* time, long index, ASIOBool) {
     return _instance->on_buffer_switch(time, index);
   }
 

From 95710aeaa20193163d78e6e90cbb9c9d84220931 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sun, 2 Jun 2019 15:25:45 +0100
Subject: [PATCH 31/97] Remove using namespace statement from <audio> header

---
 include/audio                               |  1 -
 include/audio_backend/__asio_audio_device.h |  7 +++++--
 include/audio_backend/__coreaudio_backend.h | 10 ++++++----
 include/cpp/span.hpp                        |  6 +++---
 4 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/include/audio b/include/audio
index 135f379..8cea260 100644
--- a/include/audio
+++ b/include/audio
@@ -9,7 +9,6 @@
 
 // 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
 
diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index d36551a..5ccbf03 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -1,4 +1,5 @@
 // libstdaudio
+// libstdaudio
 // Copyright (c) 2019 Andy Saul
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
@@ -78,7 +79,8 @@ class audio_device final {
     return sample_rate;
   }
 
-  span<const sample_rate_t> get_supported_sample_rates() const noexcept {
+  // TODO: remove tcb scope when std::span is used
+  tcb::span<const sample_rate_t> get_supported_sample_rates() const noexcept {
     return _sample_rates;
   }
 
@@ -93,7 +95,8 @@ class audio_device final {
     return _buffer_size;
   }
 
-  span<const buffer_size_t> get_supported_buffer_sizes_frames() const noexcept {
+  // TODO: remove tcb scope when std::span is used
+  tcb::span<const buffer_size_t> get_supported_buffer_sizes_frames() const noexcept {
     return _buffer_sizes;
   }
 
diff --git a/include/audio_backend/__coreaudio_backend.h b/include/audio_backend/__coreaudio_backend.h
index 72b2bf2..740e209 100644
--- a/include/audio_backend/__coreaudio_backend.h
+++ b/include/audio_backend/__coreaudio_backend.h
@@ -137,11 +137,12 @@ class audio_device {
     return sample_rate;
   }
 
-  span<const sample_rate_t> get_supported_sample_rates() const noexcept {
+  // TODO: remove tcb namespace when std::span is used
+  tcb::span<const sample_rate_t> get_supported_sample_rates() const noexcept {
     assert(!_supported_sample_rates.empty());
     return {
       _supported_sample_rates.data(),
-      static_cast<span<buffer_size_t>::index_type > (_supported_sample_rates.size())
+      static_cast<tcb::span<buffer_size_t>::index_type > (_supported_sample_rates.size())
       // TODO: remove the cast when you move on to a std::span implementation using index_type = size_t!
     };
   }
@@ -183,11 +184,12 @@ class audio_device {
     return buffer_size_frames;
   }
 
-  span<const buffer_size_t> get_supported_buffer_sizes_frames() const noexcept {
+  // TODO: remove tcb namespace when std::byte is used
+  tcb::span<const buffer_size_t> get_supported_buffer_sizes_frames() const noexcept {
     assert(!_supported_buffer_sizes.empty());
     return {
       _supported_buffer_sizes.data(),
-      static_cast<span<buffer_size_t>::index_type > (_supported_buffer_sizes.size())
+      static_cast<tcb::span<buffer_size_t>::index_type > (_supported_buffer_sizes.size())
       // TODO: remove the cast when you move on to a std::span implementation using index_type = size_t!
     };
   }
diff --git a/include/cpp/span.hpp b/include/cpp/span.hpp
index a6aae56..bc33365 100644
--- a/include/cpp/span.hpp
+++ b/include/cpp/span.hpp
@@ -114,9 +114,9 @@ inline void contract_violation(const char* msg)
 #define TCB_SPAN_HAVE_DEDUCTION_GUIDES
 #endif
 
-//#if defined(TCB_SPAN_HAVE_CPP17) || defined(__cpp_lib_byte)
-//#define TCB_SPAN_HAVE_STD_BYTE
-//#endif
+#if defined(TCB_SPAN_HAVE_CPP17) || defined(__cpp_lib_byte)
+#define TCB_SPAN_HAVE_STD_BYTE
+#endif
 
 #if defined(TCB_SPAN_HAVE_CPP17) || defined(__cpp_lib_array_constexpr)
 #define TCB_SPAN_HAVE_CONSTEXPR_STD_ARRAY_ETC

From 9cd0bb396a64e9e3957ca0f10ca79d1c6d63453b Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sun, 2 Jun 2019 16:15:00 +0100
Subject: [PATCH 32/97] Change buffers to work with changes in 92ca1045

---
 include/__audio_buffer.h                    | 2 +-
 include/audio_backend/__asio_audio_device.h | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/include/__audio_buffer.h b/include/__audio_buffer.h
index 380a9aa..5083cec 100644
--- a/include/__audio_buffer.h
+++ b/include/__audio_buffer.h
@@ -48,7 +48,7 @@ class audio_buffer {
     }
   }
 
-  audio_buffer(sample_type** data, index_type num_frames, index_type num_channels,ptr_to_ptr_deinterleaved_t)
+  audio_buffer(sample_type** data, index_type num_frames, index_type num_channels, ptr_to_ptr_deinterleaved_t)
       : _num_frames(num_frames),
         _num_channels(num_channels),
         _stride(1),
diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 5ccbf03..b08fa81 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -262,8 +262,8 @@ class audio_device final {
 
     _input_samples.resize(_num_inputs * _buffer_size);
     _output_samples.resize(_num_outputs * _buffer_size);
-    _io.input_buffer = {_input_samples.data(), _input_samples.size(), static_cast<size_t>(_num_inputs)};
-    _io.output_buffer = {_output_samples.data(), _output_samples.size(), static_cast<size_t>(_num_outputs)};
+    _io.input_buffer = {_input_samples.data(), static_cast<size_t>(_buffer_size), static_cast<size_t>(_num_inputs), contiguous_interleaved};
+    _io.output_buffer = {_output_samples.data(), static_cast<size_t>(_buffer_size), static_cast<size_t>(_num_outputs), contiguous_interleaved};
 
     initialise_input_buffer_fillers();
     initialise_output_buffer_fillers();

From 9aa0f297aecbcbd9bbb23f2e9a324fb6d9033efc Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sun, 2 Jun 2019 17:24:58 +0100
Subject: [PATCH 33/97] Add audio_device::start with stop/start callback
 overloads

Not sure what the implementation is supposed to be as
P1386R2 is not published yet
---
 include/audio_backend/__asio_audio_device.h | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index b08fa81..dd2a0eb 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -121,6 +121,26 @@ class audio_device final {
     return false;
   }
 
+  // TODO: remove std::function as soon as C++20 default-ctable lambda and lambda in unevaluated contexts become available
+  using no_op_t = std::function<void(audio_device&)>;
+
+  template <typename _StartCallbackType = no_op_t,
+            typename _StopCallbackType = no_op_t,
+            // TODO: is_nothrow_invocable_t does not compile, temporarily replaced with is_invocable_t
+            typename = enable_if_t<is_invocable_v<_StartCallbackType, audio_device&> && is_invocable_v<_StopCallbackType, audio_device&>>>
+  bool start(_StartCallbackType&& start_callback = [](audio_device&) noexcept {},
+             _StopCallbackType&& stop_callback = [](audio_device&) noexcept {}) {
+
+    // TODO: Implement as per P1386R2 (when published)
+    const auto success = start();
+    if (success) {
+      start_callback(*this);
+    } else {
+      stop_callback(*this);
+    }
+    return success;
+  }
+
   bool start() {
     _instance = this;
     _sample_position = 0;

From d50239b5431423eedf1943de7cf43aa90e47d9f5 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sun, 2 Jun 2019 17:31:46 +0100
Subject: [PATCH 34/97] Add stub implementation of
 set_audio_device_list_callback

---
 include/audio_backend/__windows_backend.h | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/include/audio_backend/__windows_backend.h b/include/audio_backend/__windows_backend.h
index 2a9d140..3706608 100644
--- a/include/audio_backend/__windows_backend.h
+++ b/include/audio_backend/__windows_backend.h
@@ -31,4 +31,9 @@ audio_device_list get_audio_output_device_list() {
   return devices.outputs();
 }
 
+template <typename F, typename /* = enable_if_t<std::is_nothrow_invocable_v<F>> */ >
+void set_audio_device_list_callback(F&&) {
+  // TODO: implement!
+}
+
 _LIBSTDAUDIO_NAMESPACE_END

From 4f0bfdbb249fe2945c8bab54249c62baa37ba1e7 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sun, 2 Jun 2019 20:10:04 +0100
Subject: [PATCH 35/97] Allow compilation in multiple translation units

Tests did not compile before this commit because there are two C++
source files that defined a static class member, violating ODR.
Worked around by using a the Myers singleton trick to store the
pointer, but allows it to be set on the first call.
There must be a better way. Sadly, we need a global somewhere as
you cannot pass the calling object to the ASIO API. I cannot think
of another way to do this in a header-only lib.
---
 include/audio_backend/__asio_audio_device.h | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index dd2a0eb..a1f7e63 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -142,7 +142,7 @@ class audio_device final {
   }
 
   bool start() {
-    _instance = this;
+    instance(this);
     _sample_position = 0;
     const auto result = _asio->start();
     _running = result == ASE_OK;
@@ -153,7 +153,6 @@ class audio_device final {
     //TODO: fade out to prevent audio clicks on stop
     const auto result = _asio->stop();
     _running = false;
-    _instance = nullptr;
     return result == ASE_OK;
   }
 
@@ -360,7 +359,7 @@ class audio_device final {
   }
 
   static ASIOTime* buffer_switch_time_info (ASIOTime* time, long index, ASIOBool) {
-    return _instance->on_buffer_switch(time, index);
+    return instance()->on_buffer_switch(time, index);
   }
 
   ASIOTime* on_buffer_switch(ASIOTime* time, long index) {
@@ -400,11 +399,13 @@ class audio_device final {
   fill_buffers _fill_output_buffers;
 
   vector<ASIOBufferInfo> _asio_buffers;
-  static audio_device* _instance;
   ASIOCallbacks _asio_callbacks;
-};
 
-audio_device* audio_device::_instance = nullptr;
+  static audio_device* instance(audio_device* d = nullptr) {
+    static audio_device* device = d;
+    return device;
+  }
+};
 
 class audio_device_list : public forward_list<audio_device> {
 };

From ea723d401e64d99d5b7b23bf794a0fa8278a6230 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sun, 2 Jun 2019 20:20:57 +0100
Subject: [PATCH 36/97] Use more informative names

---
 include/audio_backend/__asio_audio_device.h | 60 ++++++++++-----------
 1 file changed, 30 insertions(+), 30 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index a1f7e63..5f1aae2 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -39,7 +39,7 @@ class audio_device final {
   explicit audio_device(device_id_t id, string name, CLSID class_id, audio_direction direction)
     : _name(name), _id(id)
   {
-    initialise_asio(class_id, direction);
+    prepare_asio(class_id, direction);
   }
 
   ~audio_device() {
@@ -187,11 +187,11 @@ class audio_device final {
     }
     _user_callback = move(callback);
 
-    initialise_buffers();
+    allocate_buffers();
   }
 
 private:
-  void initialise_asio(const CLSID class_id, const audio_direction direction) {
+  void prepare_asio(const CLSID class_id, const audio_direction direction) {
     const auto result = CoCreateInstance(class_id, nullptr, CLSCTX_INPROC_SERVER, class_id, reinterpret_cast<void**>(&_asio));
     if (result) {
       throw audio_device_exception("Failed to open ASIO driver: 0x" + result);
@@ -200,19 +200,19 @@ class audio_device final {
       return;
     }
 
-    initialise_callbacks();
-    initialise_io(direction);
-    initialise_sample_rates();
+    set_callbacks();
+    query_io(direction);
+    query_sample_rates();
   }
 
-  void initialise_callbacks() {
+  void set_callbacks() {
     _asio_callbacks.bufferSwitch = &audio_device::buffer_switch;
     _asio_callbacks.bufferSwitchTimeInfo = &audio_device::buffer_switch_time_info;
     _asio_callbacks.asioMessage = &audio_device::asio_message;
     _asio_callbacks.sampleRateDidChange = &audio_device::sample_rate_changed;
   }
 
-  void initialise_io(const audio_direction direction) {
+  void query_io(const audio_direction direction) {
     const auto result = _asio->getChannels(&_num_inputs, &_num_outputs);
 
     if (result != ASE_OK) {
@@ -249,7 +249,7 @@ class audio_device final {
     _sample_type = info.type;
   }
 
-  void initialise_sample_rates()
+  void query_sample_rates()
   {
     constexpr array<sample_rate_t, 6> common_sample_rates = { 44'100, 48'000, 88'200, 96'000, 176'400, 192'000 };
 
@@ -263,7 +263,7 @@ class audio_device final {
     }
   }
 
-  void initialise_buffers() {
+  void allocate_buffers() {
 
     for (int i = 0; i < _num_inputs; ++i) {
       _asio_buffers.emplace_back(ASIOBufferInfo{ true, i });
@@ -284,14 +284,14 @@ class audio_device final {
     _io.input_buffer = {_input_samples.data(), static_cast<size_t>(_buffer_size), static_cast<size_t>(_num_inputs), contiguous_interleaved};
     _io.output_buffer = {_output_samples.data(), static_cast<size_t>(_buffer_size), static_cast<size_t>(_num_outputs), contiguous_interleaved};
 
-    initialise_input_buffer_fillers();
-    initialise_output_buffer_fillers();
+    set_input_reader();
+    set_output_writer();
   }
 
-  void initialise_input_buffer_fillers() {
+  void set_input_reader() {
 
     if (!is_input()) {
-      _fill_input_buffers = [](long) {};
+      _read = [](long) {};
       return;
     }
 
@@ -299,7 +299,7 @@ class audio_device final {
     {
     case ASIOSTInt32LSB:
     {
-      _fill_input_buffers = [&](long index) {
+      _read = [&](long index) {
         auto& in = *_io.input_buffer;
         for (int channel = 0; channel < _num_inputs; ++channel) {
           const auto buffer = static_cast<int32_t*>(_asio_buffers[channel].buffers[index]);
@@ -316,10 +316,10 @@ class audio_device final {
     }
   }
 
-  void initialise_output_buffer_fillers() {
+  void set_output_writer() {
 
     if (!is_output()) {
-      _fill_output_buffers = [](long) {};
+      _write = [](long) {};
       return;
     }
 
@@ -327,16 +327,16 @@ class audio_device final {
     {
     case ASIOSTInt32LSB:
     {
-        _fill_output_buffers = [&](long index) {
-          auto& out = *_io.output_buffer;
-          for (int channel = 0; channel < _num_outputs; ++channel) {
-            const auto buffer = static_cast<int32_t*>(_asio_buffers[_num_inputs + channel].buffers[index]);
-            for (int frame = 0; frame < out.size_frames(); ++frame) {
-              const auto sample = static_cast<int32_t>(INT32_MAX * out(frame, channel));
-              buffer[frame] = sample;
-            }
+      _write = [&](long index) {
+        auto& out = *_io.output_buffer;
+        for (int channel = 0; channel < _num_outputs; ++channel) {
+          const auto buffer = static_cast<int32_t*>(_asio_buffers[_num_inputs + channel].buffers[index]);
+          for (int frame = 0; frame < out.size_frames(); ++frame) {
+            const auto sample = static_cast<int32_t>(INT32_MAX * out(frame, channel));
+            buffer[frame] = sample;
           }
-        };
+        }
+      };
       break;
     }
     default: //TODO: Implement other sample types
@@ -364,9 +364,9 @@ class audio_device final {
 
   ASIOTime* on_buffer_switch(ASIOTime* time, long index) {
 
-    _fill_input_buffers(index);
+    _read(index);
     _user_callback(*this, _io);
-    _fill_output_buffers(index);
+    _write(index);
 
     time->timeInfo.flags = kSystemTimeValid | kSamplePositionValid;
     time->timeInfo.samplePosition = _sample_position;
@@ -395,8 +395,8 @@ class audio_device final {
   vector<float> _output_samples;
 
   using fill_buffers = function<void(long index)>;
-  fill_buffers _fill_input_buffers;
-  fill_buffers _fill_output_buffers;
+  fill_buffers _read;
+  fill_buffers _write;
 
   vector<ASIOBufferInfo> _asio_buffers;
   ASIOCallbacks _asio_callbacks;

From 9619b2ee423a0c209f8de844224e17fb9c6dfcfc Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sun, 2 Jun 2019 20:30:39 +0100
Subject: [PATCH 37/97] Include the max value for power-of-two buffer sizes

---
 include/audio_backend/__asio_audio_device.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 5f1aae2..9b53af7 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -231,7 +231,7 @@ class audio_device final {
 
     if (granularity == -1) {
       // Buffers are powers of two
-      for (long size = min; size < max; size *= 2) {
+      for (long size = min; size <= max; size *= 2) {
         _buffer_sizes.push_back(size);
       }
     }

From 008609848456776585360d24f18e9a596dc0152d Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sun, 2 Jun 2019 21:01:16 +0100
Subject: [PATCH 38/97] Extract methods to make code clearer

---
 include/audio_backend/__asio_audio_device.h | 33 +++++++++++++--------
 1 file changed, 20 insertions(+), 13 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 9b53af7..9de114e 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -229,19 +229,10 @@ class audio_device final {
     long granularity;
     _asio->getBufferSize(&min, &max, &_buffer_size, &granularity);
 
-    if (granularity == -1) {
-      // Buffers are powers of two
-      for (long size = min; size <= max; size *= 2) {
-        _buffer_sizes.push_back(size);
-      }
-    }
-    else if (granularity == 0) {
-      _buffer_sizes.push_back(_buffer_size);
-    }
-    else if (granularity > 0) {
-      for (long size = min; size <= max; size += granularity) {
-        _buffer_sizes.push_back(size);
-      }
+    switch (granularity) {
+    default: set_buffers(min, max, granularity); break;
+    case -1: set_buffers_as_powers_of_two(min, max); break;
+    case 0: set_buffers_as_default_size_only(); break;
     }
 
     ASIOChannelInfo info{0, _num_inputs > 0};
@@ -249,6 +240,22 @@ class audio_device final {
     _sample_type = info.type;
   }
 
+  void set_buffers(long min, long max, long granularity) {
+    for (long size = min; size <= max; size += granularity) {
+      _buffer_sizes.push_back(size);
+    }
+  }
+
+  void set_buffers_as_powers_of_two(long min, long max) {
+    for (long size = min; size <= max; size *= 2) {
+      _buffer_sizes.push_back(size);
+    }
+  }
+
+  void set_buffers_as_default_size_only() {
+    _buffer_sizes.push_back(_buffer_size);
+  }
+
   void query_sample_rates()
   {
     constexpr array<sample_rate_t, 6> common_sample_rates = { 44'100, 48'000, 88'200, 96'000, 176'400, 192'000 };

From df8dcb14841080c78f126a88f0d79359d6d4b355 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sun, 2 Jun 2019 22:11:18 +0100
Subject: [PATCH 39/97] Add support for non-timestamped ASIO drivers & 24-bit
 packed outputs

---
 include/audio_backend/__asio_audio_device.h | 42 ++++++++++++++++++---
 1 file changed, 37 insertions(+), 5 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 9de114e..199dd20 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -44,7 +44,9 @@ class audio_device final {
 
   ~audio_device() {
     stop();
-    _asio->disposeBuffers();
+    if (!_asio_buffers.empty()) {
+      _asio->disposeBuffers();
+    }
   }
 
   string_view name() const noexcept {
@@ -346,13 +348,29 @@ class audio_device final {
       };
       break;
     }
+
+    case ASIOSTInt24LSB:
+    {
+      _write = [&](long index) {
+        auto& out = *_io.output_buffer;
+        for (int channel = 0; channel < _num_outputs; ++channel) {
+          const auto buffer = static_cast<int8_t*>(_asio_buffers[_num_inputs + channel].buffers[index]);
+          int byte_offset = 0;
+          for (int frame = 0; frame < out.size_frames(); ++frame) {
+            const auto sample = static_cast<int32_t>(0x7f'ffff * out(frame, channel));
+            buffer[byte_offset++] = 0xff & sample;
+            buffer[byte_offset++] = 0xff & (sample >> 8);
+            buffer[byte_offset++] = 0xff & (sample >> 16);;
+          }
+        }
+      };
+      break;
+    }
     default: //TODO: Implement other sample types
       throw audio_device_exception("ASIO native sample type not supported: " + _sample_type);
     }
   }
 
-  static void buffer_switch(long, ASIOBool) {}
-
   static void sample_rate_changed(ASIOSampleRate) {}
 
   static long asio_message(long selector, long, void*, double*) {
@@ -365,6 +383,20 @@ class audio_device final {
     }
   }
 
+  static void buffer_switch(long index, ASIOBool)
+  {
+    instance()->on_buffer_switch(index);
+  }
+
+  void on_buffer_switch(long index) {
+
+    _read(index);
+    _user_callback(*this, _io);
+    _write(index);
+
+    _asio->outputReady();
+  }
+
   static ASIOTime* buffer_switch_time_info (ASIOTime* time, long index, ASIOBool) {
     return instance()->on_buffer_switch(time, index);
   }
@@ -547,8 +579,8 @@ class __asio_devices {
 
   bool is_excluded(string_view name) const {
     if (name == "Realtek ASIO") {
-      // Realtek ASIO drivers require features that are not implemented yet,
-      // namely using 24-bit packed samples & non-timestamped buffer switch callbacks
+      // Realtek ASIO drivers seem unstable
+      // Every other time is IASIO::createBuffers called, it fails with ASE_InvalidMode
       return true;
     }
     return false;

From 2ef3d8ac781ec9ca6339bbb54fa079f5832dc8df Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Mon, 3 Jun 2019 21:58:33 +0100
Subject: [PATCH 40/97] Define some sample types & tests

---
 CMakeLists.txt                              |  8 ++-
 include/audio_backend/__asio_audio_device.h | 55 ++++++++++++++++-----
 test/asio_test.cpp                          | 33 +++++++++++++
 3 files changed, 84 insertions(+), 12 deletions(-)
 create mode 100644 test/asio_test.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index c3cf4d4..05f8911 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -33,4 +33,10 @@ add_executable(level_meter examples/level_meter.cpp)
 add_executable(test
         test/test_main.cpp
         test/audio_buffer_test.cpp
-        test/audio_device_test.cpp)
\ No newline at end of file
+        test/audio_device_test.cpp)
+
+if (MSVC)
+add_executable(test_asio
+        test/test_main.cpp
+        test/asio_test.cpp)
+endif ()
\ No newline at end of file
diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 199dd20..cd78a85 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -1,5 +1,4 @@
 // libstdaudio
-// libstdaudio
 // Copyright (c) 2019 Andy Saul
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
@@ -29,9 +28,48 @@ struct audio_device_exception : public runtime_error {
   }
 };
 
+class __asio_sample_int32_t
+{
+public:
+  static constexpr double _scale = INT32_MAX;
+  __asio_sample_int32_t() = default;
+  __asio_sample_int32_t(int32_t value)
+    : value{value}
+  {}
+  __asio_sample_int32_t(float value)
+    : __asio_sample_int32_t{static_cast<int32_t>(value * _scale)}
+  {}
+
+  int32_t int_value() const {
+    return value;
+  }
+
+private:
+  int32_t value;
+};
+
+class alignas(1) __asio_sample_int24_t
+{
+public:
+  static constexpr int32_t _scale = 0x7f'ffff;
+  __asio_sample_int24_t() = default;
+  __asio_sample_int24_t(int32_t value)
+    : data{value & 0xff, (value >> 8) & 0xff, (value >> 16) & 0xff}
+  {}
+  __asio_sample_int24_t(float value)
+    : __asio_sample_int24_t{static_cast<int32_t>(value * _scale)}
+  {}
+
+  int32_t int_value() const {
+    return ((data[2] << 24) >> 8) | ((data[1] << 8) & 0xff00) | (data[0] & 0xff);
+  }
+
+private:
+  array<int8_t, 3> data;
+};
+
 enum class audio_direction {in, out, full_duplex};
 
-// TODO: templatize audio_device as per 6.4 Device Selection API
 class audio_device final {
 public:
   using device_id_t = int;
@@ -339,10 +377,9 @@ class audio_device final {
       _write = [&](long index) {
         auto& out = *_io.output_buffer;
         for (int channel = 0; channel < _num_outputs; ++channel) {
-          const auto buffer = static_cast<int32_t*>(_asio_buffers[_num_inputs + channel].buffers[index]);
+          const auto buffer = static_cast<__asio_sample_int32_t*>(_asio_buffers[_num_inputs + channel].buffers[index]);
           for (int frame = 0; frame < out.size_frames(); ++frame) {
-            const auto sample = static_cast<int32_t>(INT32_MAX * out(frame, channel));
-            buffer[frame] = sample;
+            buffer[frame] = __asio_sample_int32_t{out(frame, channel)};
           }
         }
       };
@@ -354,13 +391,9 @@ class audio_device final {
       _write = [&](long index) {
         auto& out = *_io.output_buffer;
         for (int channel = 0; channel < _num_outputs; ++channel) {
-          const auto buffer = static_cast<int8_t*>(_asio_buffers[_num_inputs + channel].buffers[index]);
-          int byte_offset = 0;
+          const auto buffer = static_cast<__asio_sample_int24_t*>(_asio_buffers[_num_inputs + channel].buffers[index]);
           for (int frame = 0; frame < out.size_frames(); ++frame) {
-            const auto sample = static_cast<int32_t>(0x7f'ffff * out(frame, channel));
-            buffer[byte_offset++] = 0xff & sample;
-            buffer[byte_offset++] = 0xff & (sample >> 8);
-            buffer[byte_offset++] = 0xff & (sample >> 16);;
+            buffer[frame] = __asio_sample_int24_t(out(frame, channel));
           }
         }
       };
diff --git a/test/asio_test.cpp b/test/asio_test.cpp
new file mode 100644
index 0000000..a07b28a
--- /dev/null
+++ b/test/asio_test.cpp
@@ -0,0 +1,33 @@
+// libstdaudio
+// Copyright (c) 2019 - Andy Saul
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+
+#include <audio>
+#include <array>
+#include "catch/catch.hpp"
+
+using namespace std::experimental;
+
+TEST_CASE("Converts floating point samples to integer samples", "[asio]")
+{
+
+  SECTION("Converts to 32-bit samples")
+  {
+    CHECK(__asio_sample_int32_t(0.f).int_value() == 0);
+    CHECK(__asio_sample_int32_t(1.f).int_value() == 0x7fff'ffff);
+    CHECK(__asio_sample_int32_t(-1.f).int_value() == -0x7fff'ffff);
+    CHECK(__asio_sample_int32_t(0.5f).int_value() == 0x7fff'ffff / 2);
+    CHECK(__asio_sample_int32_t(-0.5f).int_value() == -0x7fff'ffff / 2);
+  }
+
+  SECTION("Converts to 24-bit samples")
+  {
+    CHECK(__asio_sample_int24_t(0.f).int_value() == 0);
+    CHECK(__asio_sample_int24_t(1.f).int_value() == 0x7f'ffff);
+    CHECK(__asio_sample_int24_t(-1.f).int_value() == -0x7f'ffff);
+    CHECK(__asio_sample_int24_t(0.5f).int_value() == 0x7f'ffff / 2);
+    CHECK(__asio_sample_int24_t(-0.5f).int_value() == -0x7f'ffff / 2);
+  }
+}
+

From 3042e020dc4d93882afc0fccf1d1c2a02abe9034 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Tue, 4 Jun 2019 23:24:57 +0100
Subject: [PATCH 41/97] Move __asio_sample classes to separate header

---
 include/audio_backend/__asio_audio_device.h | 43 +----------------
 include/audio_backend/__asio_sample.h       | 52 +++++++++++++++++++++
 2 files changed, 54 insertions(+), 41 deletions(-)
 create mode 100644 include/audio_backend/__asio_sample.h

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index cd78a85..3baccc1 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -5,6 +5,8 @@
 
 #pragma once
 
+#include "__asio_sample.h"
+
 #include "iasiodrv.h"
 
 #include <string_view>
@@ -27,47 +29,6 @@ struct audio_device_exception : public runtime_error {
     : runtime_error(what) {
   }
 };
-
-class __asio_sample_int32_t
-{
-public:
-  static constexpr double _scale = INT32_MAX;
-  __asio_sample_int32_t() = default;
-  __asio_sample_int32_t(int32_t value)
-    : value{value}
-  {}
-  __asio_sample_int32_t(float value)
-    : __asio_sample_int32_t{static_cast<int32_t>(value * _scale)}
-  {}
-
-  int32_t int_value() const {
-    return value;
-  }
-
-private:
-  int32_t value;
-};
-
-class alignas(1) __asio_sample_int24_t
-{
-public:
-  static constexpr int32_t _scale = 0x7f'ffff;
-  __asio_sample_int24_t() = default;
-  __asio_sample_int24_t(int32_t value)
-    : data{value & 0xff, (value >> 8) & 0xff, (value >> 16) & 0xff}
-  {}
-  __asio_sample_int24_t(float value)
-    : __asio_sample_int24_t{static_cast<int32_t>(value * _scale)}
-  {}
-
-  int32_t int_value() const {
-    return ((data[2] << 24) >> 8) | ((data[1] << 8) & 0xff00) | (data[0] & 0xff);
-  }
-
-private:
-  array<int8_t, 3> data;
-};
-
 enum class audio_direction {in, out, full_duplex};
 
 class audio_device final {
diff --git a/include/audio_backend/__asio_sample.h b/include/audio_backend/__asio_sample.h
new file mode 100644
index 0000000..aa79bec
--- /dev/null
+++ b/include/audio_backend/__asio_sample.h
@@ -0,0 +1,52 @@
+// libstdaudio
+// Copyright (c) 2019 Andy Saul
+// 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 <array>
+
+_LIBSTDAUDIO_NAMESPACE_BEGIN
+
+class __asio_sample_int32_t
+{
+public:
+  static constexpr double _scale = INT32_MAX;
+  __asio_sample_int32_t() = default;
+  __asio_sample_int32_t(int32_t value)
+    : value{ value }
+  {}
+  __asio_sample_int32_t(float value)
+    : __asio_sample_int32_t{ static_cast<int32_t>(value * _scale) }
+  {}
+
+  int32_t int_value() const {
+    return value;
+  }
+
+private:
+  int32_t value;
+};
+
+class alignas(1) __asio_sample_int24_t
+{
+public:
+  static constexpr int32_t _scale = 0x7f'ffff;
+  __asio_sample_int24_t() = default;
+  __asio_sample_int24_t(int32_t value)
+    : data{ value & 0xff, (value >> 8) & 0xff, (value >> 16) & 0xff }
+  {}
+  __asio_sample_int24_t(float value)
+    : __asio_sample_int24_t{ static_cast<int32_t>(value * _scale) }
+  {}
+
+  int32_t int_value() const {
+    return ((data[2] << 24) >> 8) | ((data[1] << 8) & 0xff00) | (data[0] & 0xff);
+  }
+
+private:
+  array<int8_t, 3> data;
+};
+
+_LIBSTDAUDIO_NAMESPACE_END

From b8ebb914ceda2e8cf68e913a231ab2bc61651a19 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Tue, 4 Jun 2019 23:07:13 +0100
Subject: [PATCH 42/97] Templatize __asio_sample

---
 include/audio_backend/__asio_audio_device.h |  6 ++++--
 include/audio_backend/__asio_sample.h       | 14 +++++++-------
 test/asio_test.cpp                          | 10 +++++-----
 3 files changed, 16 insertions(+), 14 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 3baccc1..960bb92 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -15,6 +15,7 @@
 #include <forward_list>
 #include <vector>
 #include <functional>
+#include <numeric>
 
 #define WIN32_LEAN_AND_MEAN
 #include <Windows.h>
@@ -29,6 +30,7 @@ struct audio_device_exception : public runtime_error {
     : runtime_error(what) {
   }
 };
+
 enum class audio_direction {in, out, full_duplex};
 
 class audio_device final {
@@ -338,9 +340,9 @@ class audio_device final {
       _write = [&](long index) {
         auto& out = *_io.output_buffer;
         for (int channel = 0; channel < _num_outputs; ++channel) {
-          const auto buffer = static_cast<__asio_sample_int32_t*>(_asio_buffers[_num_inputs + channel].buffers[index]);
+          const auto buffer = static_cast<__asio_sample<int32_t>*>(_asio_buffers[_num_inputs + channel].buffers[index]);
           for (int frame = 0; frame < out.size_frames(); ++frame) {
-            buffer[frame] = __asio_sample_int32_t{out(frame, channel)};
+            buffer[frame] = __asio_sample<int32_t>{out(frame, channel)};
           }
         }
       };
diff --git a/include/audio_backend/__asio_sample.h b/include/audio_backend/__asio_sample.h
index aa79bec..594e3a6 100644
--- a/include/audio_backend/__asio_sample.h
+++ b/include/audio_backend/__asio_sample.h
@@ -9,16 +9,16 @@
 
 _LIBSTDAUDIO_NAMESPACE_BEGIN
 
-class __asio_sample_int32_t
+template <typename _SampleType>
+class __asio_sample
 {
 public:
-  static constexpr double _scale = INT32_MAX;
-  __asio_sample_int32_t() = default;
-  __asio_sample_int32_t(int32_t value)
+  __asio_sample() = default;
+  __asio_sample(_SampleType value)
     : value{ value }
   {}
-  __asio_sample_int32_t(float value)
-    : __asio_sample_int32_t{ static_cast<int32_t>(value * _scale) }
+  __asio_sample(float value)
+    : __asio_sample(static_cast<_SampleType>(value * static_cast<double>(numeric_limits<_SampleType>::max())))
   {}
 
   int32_t int_value() const {
@@ -26,7 +26,7 @@ class __asio_sample_int32_t
   }
 
 private:
-  int32_t value;
+  _SampleType value;
 };
 
 class alignas(1) __asio_sample_int24_t
diff --git a/test/asio_test.cpp b/test/asio_test.cpp
index a07b28a..02e393f 100644
--- a/test/asio_test.cpp
+++ b/test/asio_test.cpp
@@ -14,11 +14,11 @@ TEST_CASE("Converts floating point samples to integer samples", "[asio]")
 
   SECTION("Converts to 32-bit samples")
   {
-    CHECK(__asio_sample_int32_t(0.f).int_value() == 0);
-    CHECK(__asio_sample_int32_t(1.f).int_value() == 0x7fff'ffff);
-    CHECK(__asio_sample_int32_t(-1.f).int_value() == -0x7fff'ffff);
-    CHECK(__asio_sample_int32_t(0.5f).int_value() == 0x7fff'ffff / 2);
-    CHECK(__asio_sample_int32_t(-0.5f).int_value() == -0x7fff'ffff / 2);
+    CHECK(__asio_sample<int32_t>(0.f).int_value() == 0);
+    CHECK(__asio_sample<int32_t>(1.f).int_value() == 0x7fff'ffff);
+    CHECK(__asio_sample<int32_t>(-1.f).int_value() == -0x7fff'ffff);
+    CHECK(__asio_sample<int32_t>(0.5f).int_value() == 0x7fff'ffff / 2);
+    CHECK(__asio_sample<int32_t>(-0.5f).int_value() == -0x7fff'ffff / 2);
   }
 
   SECTION("Converts to 24-bit samples")

From 0d9615a6aa3c7fd73a9a326456a04107588fcd3f Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Tue, 4 Jun 2019 23:52:49 +0100
Subject: [PATCH 43/97] Provide template specialization for
 __asio_sample<packed24_t>

---
 include/audio_backend/__asio_audio_device.h |  5 ++---
 include/audio_backend/__asio_sample.h       | 14 +++++++++-----
 test/asio_test.cpp                          | 10 +++++-----
 3 files changed, 16 insertions(+), 13 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 960bb92..5f6b345 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -15,7 +15,6 @@
 #include <forward_list>
 #include <vector>
 #include <functional>
-#include <numeric>
 
 #define WIN32_LEAN_AND_MEAN
 #include <Windows.h>
@@ -354,9 +353,9 @@ class audio_device final {
       _write = [&](long index) {
         auto& out = *_io.output_buffer;
         for (int channel = 0; channel < _num_outputs; ++channel) {
-          const auto buffer = static_cast<__asio_sample_int24_t*>(_asio_buffers[_num_inputs + channel].buffers[index]);
+          const auto buffer = static_cast<__asio_sample<packed24_t>*>(_asio_buffers[_num_inputs + channel].buffers[index]);
           for (int frame = 0; frame < out.size_frames(); ++frame) {
-            buffer[frame] = __asio_sample_int24_t(out(frame, channel));
+            buffer[frame] = __asio_sample<packed24_t>(out(frame, channel));
           }
         }
       };
diff --git a/include/audio_backend/__asio_sample.h b/include/audio_backend/__asio_sample.h
index 594e3a6..d30fbfe 100644
--- a/include/audio_backend/__asio_sample.h
+++ b/include/audio_backend/__asio_sample.h
@@ -6,6 +6,7 @@
 #pragma once
 
 #include <array>
+#include <numeric>
 
 _LIBSTDAUDIO_NAMESPACE_BEGIN
 
@@ -29,16 +30,19 @@ class __asio_sample
   _SampleType value;
 };
 
-class alignas(1) __asio_sample_int24_t
+struct packed24_t{};
+
+template <>
+class alignas(1) __asio_sample<packed24_t>
 {
 public:
   static constexpr int32_t _scale = 0x7f'ffff;
-  __asio_sample_int24_t() = default;
-  __asio_sample_int24_t(int32_t value)
+  __asio_sample() = default;
+  __asio_sample(int32_t value)
     : data{ value & 0xff, (value >> 8) & 0xff, (value >> 16) & 0xff }
   {}
-  __asio_sample_int24_t(float value)
-    : __asio_sample_int24_t{ static_cast<int32_t>(value * _scale) }
+  __asio_sample(float value)
+    : __asio_sample{ static_cast<int32_t>(value * _scale) }
   {}
 
   int32_t int_value() const {
diff --git a/test/asio_test.cpp b/test/asio_test.cpp
index 02e393f..905006e 100644
--- a/test/asio_test.cpp
+++ b/test/asio_test.cpp
@@ -23,11 +23,11 @@ TEST_CASE("Converts floating point samples to integer samples", "[asio]")
 
   SECTION("Converts to 24-bit samples")
   {
-    CHECK(__asio_sample_int24_t(0.f).int_value() == 0);
-    CHECK(__asio_sample_int24_t(1.f).int_value() == 0x7f'ffff);
-    CHECK(__asio_sample_int24_t(-1.f).int_value() == -0x7f'ffff);
-    CHECK(__asio_sample_int24_t(0.5f).int_value() == 0x7f'ffff / 2);
-    CHECK(__asio_sample_int24_t(-0.5f).int_value() == -0x7f'ffff / 2);
+    CHECK(__asio_sample<packed24_t>(0.f).int_value() == 0);
+    CHECK(__asio_sample<packed24_t>(1.f).int_value() == 0x7f'ffff);
+    CHECK(__asio_sample<packed24_t>(-1.f).int_value() == -0x7f'ffff);
+    CHECK(__asio_sample<packed24_t>(0.5f).int_value() == 0x7f'ffff / 2);
+    CHECK(__asio_sample<packed24_t>(-0.5f).int_value() == -0x7f'ffff / 2);
   }
 }
 

From a359170ada91c6dadd4643e8093b66f135f5fcae Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Wed, 5 Jun 2019 00:01:48 +0100
Subject: [PATCH 44/97] Templatize write function

---
 include/audio_backend/__asio_audio_device.h | 42 ++++++++-------------
 test/asio_test.cpp                          |  9 +++++
 2 files changed, 24 insertions(+), 27 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 5f6b345..7b94f03 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -334,35 +334,22 @@ class audio_device final {
 
     switch (_sample_type)
     {
-    case ASIOSTInt32LSB:
-    {
-      _write = [&](long index) {
-        auto& out = *_io.output_buffer;
-        for (int channel = 0; channel < _num_outputs; ++channel) {
-          const auto buffer = static_cast<__asio_sample<int32_t>*>(_asio_buffers[_num_inputs + channel].buffers[index]);
-          for (int frame = 0; frame < out.size_frames(); ++frame) {
-            buffer[frame] = __asio_sample<int32_t>{out(frame, channel)};
-          }
-        }
-      };
-      break;
-    }
+    case ASIOSTInt32LSB: _write = [this](long index) { write<int32_t>(index); }; break;
+    case ASIOSTInt24LSB: _write = [this](long index) { write<packed24_t>(index); }; break;
+    case ASIOSTInt16LSB: _write = [this](long index) { write<int16_t>(index); }; break;
 
-    case ASIOSTInt24LSB:
-    {
-      _write = [&](long index) {
-        auto& out = *_io.output_buffer;
-        for (int channel = 0; channel < _num_outputs; ++channel) {
-          const auto buffer = static_cast<__asio_sample<packed24_t>*>(_asio_buffers[_num_inputs + channel].buffers[index]);
-          for (int frame = 0; frame < out.size_frames(); ++frame) {
-            buffer[frame] = __asio_sample<packed24_t>(out(frame, channel));
-          }
-        }
-      };
-      break;
+    default: throw audio_device_exception("ASIO native sample type not supported: " + _sample_type);
     }
-    default: //TODO: Implement other sample types
-      throw audio_device_exception("ASIO native sample type not supported: " + _sample_type);
+  }
+
+  template <typename _SampleType>
+  void write (long index) {
+    auto& out = *_io.output_buffer;
+    for (int channel = 0; channel < _num_outputs; ++channel) {
+      const auto buffer = static_cast<__asio_sample<_SampleType>*>(_asio_buffers[_num_inputs + channel].buffers[index]);
+      for (int frame = 0; frame < out.size_frames(); ++frame) {
+        buffer[frame] = __asio_sample<_SampleType>{ out(frame, channel) };
+      }
     }
   }
 
@@ -576,6 +563,7 @@ class __asio_devices {
     if (name == "Realtek ASIO") {
       // Realtek ASIO drivers seem unstable
       // Every other time is IASIO::createBuffers called, it fails with ASE_InvalidMode
+      // Play continues after stop is called
       return true;
     }
     return false;
diff --git a/test/asio_test.cpp b/test/asio_test.cpp
index 905006e..9fd9147 100644
--- a/test/asio_test.cpp
+++ b/test/asio_test.cpp
@@ -29,5 +29,14 @@ TEST_CASE("Converts floating point samples to integer samples", "[asio]")
     CHECK(__asio_sample<packed24_t>(0.5f).int_value() == 0x7f'ffff / 2);
     CHECK(__asio_sample<packed24_t>(-0.5f).int_value() == -0x7f'ffff / 2);
   }
+
+  SECTION("Converts to 16-bit samples")
+  {
+    CHECK(__asio_sample<int16_t>(0.f).int_value() == 0);
+    CHECK(__asio_sample<int16_t>(1.f).int_value() == 0x7fff);
+    CHECK(__asio_sample<int16_t>(-1.f).int_value() == -0x7fff);
+    CHECK(__asio_sample<int16_t>(0.5f).int_value() == 0x7fff / 2);
+    CHECK(__asio_sample<int16_t>(-0.5f).int_value() == -0x7fff / 2);
+  }
 }
 

From 32f77393d819075994bb656d2d0ea96e5d7c34b5 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Wed, 5 Jun 2019 00:27:22 +0100
Subject: [PATCH 45/97] Move size var into same scope as RegEnumKey so that
 full name is always read

---
 include/audio_backend/__asio_audio_device.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 7b94f03..07b0f68 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -451,10 +451,10 @@ class __reg_key_reader final
   vector<string> subkeys() const {
     constexpr int max_asio_name_length{32};
     char name[max_asio_name_length];
-    DWORD size{max_asio_name_length};
     vector<string> keys;
 
     for (DWORD index = 0; ; ++index) {
+      DWORD size{max_asio_name_length};
       const auto result = RegEnumKeyEx(_key, index, name, &size, nullptr, nullptr, nullptr, nullptr);
 
       if (result != ERROR_SUCCESS) {

From 48200db4265d9d096310ed78cb3a27ad326101a8 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Wed, 5 Jun 2019 08:15:27 +0100
Subject: [PATCH 46/97] Remove unnecessary duplication

---
 include/audio_backend/__asio_audio_device.h | 2 +-
 include/audio_backend/__windows_backend.h   | 2 --
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 07b0f68..7c20ae0 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -348,7 +348,7 @@ class audio_device final {
     for (int channel = 0; channel < _num_outputs; ++channel) {
       const auto buffer = static_cast<__asio_sample<_SampleType>*>(_asio_buffers[_num_inputs + channel].buffers[index]);
       for (int frame = 0; frame < out.size_frames(); ++frame) {
-        buffer[frame] = __asio_sample<_SampleType>{ out(frame, channel) };
+        buffer[frame] = {out(frame, channel)};
       }
     }
   }
diff --git a/include/audio_backend/__windows_backend.h b/include/audio_backend/__windows_backend.h
index 3706608..80ca71d 100644
--- a/include/audio_backend/__windows_backend.h
+++ b/include/audio_backend/__windows_backend.h
@@ -9,8 +9,6 @@
 
 _LIBSTDAUDIO_NAMESPACE_BEGIN
 
-// TODO: templatize audio_device as per 6.4 Device Selection API
-// This will allow us to select between ASIO & WASAPI
 optional<audio_device> get_default_audio_input_device() {
   auto& devices = __asio_devices::get();
   return devices.default_input();

From 59e981a221d476ffecbf5f63d18f7d86ab6569f1 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Wed, 5 Jun 2019 09:24:29 +0100
Subject: [PATCH 47/97] Use __asio_sample in read function

---
 include/audio_backend/__asio_audio_device.h |  5 ++---
 include/audio_backend/__asio_sample.h       |  8 ++++++--
 test/asio_test.cpp                          | 12 +++++++++++-
 3 files changed, 19 insertions(+), 6 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 7c20ae0..e604828 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -311,10 +311,9 @@ class audio_device final {
       _read = [&](long index) {
         auto& in = *_io.input_buffer;
         for (int channel = 0; channel < _num_inputs; ++channel) {
-          const auto buffer = static_cast<int32_t*>(_asio_buffers[channel].buffers[index]);
+          const auto buffer = static_cast<__asio_sample<int32_t>*>(_asio_buffers[channel].buffers[index]);
           for (int frame = 0; frame < in.size_frames(); ++frame) {
-            const auto sample = static_cast<float>(buffer[frame]) / INT32_MAX;
-            in(frame, channel) = sample;
+            in(frame, channel) = buffer[frame].float_value();
           }
         }
       };
diff --git a/include/audio_backend/__asio_sample.h b/include/audio_backend/__asio_sample.h
index d30fbfe..5527703 100644
--- a/include/audio_backend/__asio_sample.h
+++ b/include/audio_backend/__asio_sample.h
@@ -15,10 +15,10 @@ class __asio_sample
 {
 public:
   __asio_sample() = default;
-  __asio_sample(_SampleType value)
+  explicit __asio_sample(_SampleType value)
     : value{ value }
   {}
-  __asio_sample(float value)
+  explicit __asio_sample(float value)
     : __asio_sample(static_cast<_SampleType>(value * static_cast<double>(numeric_limits<_SampleType>::max())))
   {}
 
@@ -26,6 +26,10 @@ class __asio_sample
     return value;
   }
 
+  float float_value() const {
+    return static_cast<float>(value) / numeric_limits<_SampleType>::max();
+  }
+
 private:
   _SampleType value;
 };
diff --git a/test/asio_test.cpp b/test/asio_test.cpp
index 9fd9147..d277722 100644
--- a/test/asio_test.cpp
+++ b/test/asio_test.cpp
@@ -11,7 +11,6 @@ using namespace std::experimental;
 
 TEST_CASE("Converts floating point samples to integer samples", "[asio]")
 {
-
   SECTION("Converts to 32-bit samples")
   {
     CHECK(__asio_sample<int32_t>(0.f).int_value() == 0);
@@ -40,3 +39,14 @@ TEST_CASE("Converts floating point samples to integer samples", "[asio]")
   }
 }
 
+TEST_CASE("Converts integer samples to floating point samples", "[asio]")
+{
+  SECTION("Converts to 32-bit samples")
+  {
+    CHECK(__asio_sample<int32_t>(0).float_value() == 0.f);
+    CHECK(__asio_sample<int32_t>(0x7fff'ffff).float_value() == 1.f);
+    CHECK(__asio_sample<int32_t>(-0x7fff'ffff).float_value() == -1.f);
+    CHECK(__asio_sample<int32_t>(0x7fff'ffff / 2).float_value() == 0.5f);
+    CHECK(__asio_sample<int32_t>(-0x7fff'ffff / 2).float_value() == -0.5f);
+  }
+}

From dc84a564dea18fa187dfeb00c8c75655accecd0e Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Wed, 5 Jun 2019 18:59:24 +0100
Subject: [PATCH 48/97] Templatize read function

---
 include/audio_backend/__asio_audio_device.h | 31 +++++++++---------
 include/audio_backend/__asio_sample.h       |  4 +++
 test/asio_test.cpp                          | 35 ++++++++++++++++++++-
 3 files changed, 55 insertions(+), 15 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index e604828..b55e98b 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -306,21 +306,23 @@ class audio_device final {
 
     switch (_sample_type)
     {
-    case ASIOSTInt32LSB:
-    {
-      _read = [&](long index) {
-        auto& in = *_io.input_buffer;
-        for (int channel = 0; channel < _num_inputs; ++channel) {
-          const auto buffer = static_cast<__asio_sample<int32_t>*>(_asio_buffers[channel].buffers[index]);
-          for (int frame = 0; frame < in.size_frames(); ++frame) {
-            in(frame, channel) = buffer[frame].float_value();
-          }
-        }
-      };
-      break;
+    case ASIOSTInt32LSB: _read = [this](long index) { read<int32_t>(index); }; break;
+    case ASIOSTInt24LSB: _read = [this](long index) { read<packed24_t>(index); }; break;
+    case ASIOSTInt16LSB: _read = [this](long index) { read<int16_t>(index); }; break;
+
+    default: throw audio_device_exception("ASIO native sample type not supported: " + _sample_type);
     }
-    default: //TODO: Implement other sample types
-      throw audio_device_exception("ASIO native sample type not supported: " + _sample_type);
+  }
+
+  template <typename _SampleType>
+  void read (long index) {
+
+    auto& in = *_io.input_buffer;
+    for (int channel = 0; channel < _num_inputs; ++channel) {
+      const auto buffer = static_cast<__asio_sample<_SampleType>*>(_asio_buffers[channel].buffers[index]);
+      for (int frame = 0; frame < in.size_frames(); ++frame) {
+        in(frame, channel) = buffer[frame].float_value();
+      }
     }
   }
 
@@ -343,6 +345,7 @@ class audio_device final {
 
   template <typename _SampleType>
   void write (long index) {
+
     auto& out = *_io.output_buffer;
     for (int channel = 0; channel < _num_outputs; ++channel) {
       const auto buffer = static_cast<__asio_sample<_SampleType>*>(_asio_buffers[_num_inputs + channel].buffers[index]);
diff --git a/include/audio_backend/__asio_sample.h b/include/audio_backend/__asio_sample.h
index 5527703..67dcd1f 100644
--- a/include/audio_backend/__asio_sample.h
+++ b/include/audio_backend/__asio_sample.h
@@ -53,6 +53,10 @@ class alignas(1) __asio_sample<packed24_t>
     return ((data[2] << 24) >> 8) | ((data[1] << 8) & 0xff00) | (data[0] & 0xff);
   }
 
+  float float_value() const {
+    return static_cast<float>(int_value()) / _scale;
+  }
+
 private:
   array<int8_t, 3> data;
 };
diff --git a/test/asio_test.cpp b/test/asio_test.cpp
index d277722..94e7b97 100644
--- a/test/asio_test.cpp
+++ b/test/asio_test.cpp
@@ -41,7 +41,7 @@ TEST_CASE("Converts floating point samples to integer samples", "[asio]")
 
 TEST_CASE("Converts integer samples to floating point samples", "[asio]")
 {
-  SECTION("Converts to 32-bit samples")
+  SECTION("Converts from 32-bit samples")
   {
     CHECK(__asio_sample<int32_t>(0).float_value() == 0.f);
     CHECK(__asio_sample<int32_t>(0x7fff'ffff).float_value() == 1.f);
@@ -49,4 +49,37 @@ TEST_CASE("Converts integer samples to floating point samples", "[asio]")
     CHECK(__asio_sample<int32_t>(0x7fff'ffff / 2).float_value() == 0.5f);
     CHECK(__asio_sample<int32_t>(-0x7fff'ffff / 2).float_value() == -0.5f);
   }
+
+  SECTION("Converts from 24-bit samples")
+  {
+    CHECK(__asio_sample<packed24_t>(0).float_value() == 0.f);;
+    CHECK(__asio_sample<packed24_t>(0x7f'ffff).float_value() == 1.f);
+    CHECK(__asio_sample<packed24_t>(-0x7f'ffff).float_value() == -1.f);
+
+    const auto half = __asio_sample<packed24_t>(0x7f'ffff / 2).float_value();
+    CHECK(Approx(half) == 0.5f);
+
+    const auto minus_half = __asio_sample<packed24_t>(-0x7f'ffff / 2).float_value();
+    CHECK(Approx(minus_half) == -0.5f);
+  }
+
+  SECTION("Converts from 16-bit samples")
+  {
+    int16_t value = 0;
+    CHECK(__asio_sample<int16_t>(value).float_value() == 0.f);
+
+    value = 0x7fff;
+    CHECK(__asio_sample<int16_t>(value).float_value() == 1.f);
+
+    value = -0x7fff;
+    CHECK(__asio_sample<int16_t>(value).float_value() == -1.f);
+
+    value = 0x7fff / 2;
+    const auto half = __asio_sample<int16_t>(value).float_value();
+    CHECK(Approx(half).epsilon(0.0001f) == 0.5f);
+
+    value = -0x7fff / 2;
+    const auto minus_half = __asio_sample<int16_t>(value).float_value();
+    CHECK(Approx(minus_half).epsilon(0.0001f) == -0.5f);
+  }
 }

From 21fd50cdf5c42f6566c6c3d16525558797256274 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Wed, 5 Jun 2019 20:20:19 +0100
Subject: [PATCH 49/97] Support ASIO float types

---
 include/audio_backend/__asio_audio_device.h |  4 ++++
 include/audio_backend/__asio_sample.h       | 19 +++++++++++++++----
 2 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index b55e98b..471532d 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -309,6 +309,8 @@ class audio_device final {
     case ASIOSTInt32LSB: _read = [this](long index) { read<int32_t>(index); }; break;
     case ASIOSTInt24LSB: _read = [this](long index) { read<packed24_t>(index); }; break;
     case ASIOSTInt16LSB: _read = [this](long index) { read<int16_t>(index); }; break;
+    case ASIOSTFloat32LSB: _read = [this](long index) { read<float>(index); }; break;
+    case ASIOSTFloat64LSB: _read = [this](long index) { read<double>(index); }; break;
 
     default: throw audio_device_exception("ASIO native sample type not supported: " + _sample_type);
     }
@@ -338,6 +340,8 @@ class audio_device final {
     case ASIOSTInt32LSB: _write = [this](long index) { write<int32_t>(index); }; break;
     case ASIOSTInt24LSB: _write = [this](long index) { write<packed24_t>(index); }; break;
     case ASIOSTInt16LSB: _write = [this](long index) { write<int16_t>(index); }; break;
+    case ASIOSTFloat32LSB: _write = [this](long index) { write<float>(index); }; break;
+    case ASIOSTFloat64LSB: _write = [this](long index) { write<double>(index); }; break;
 
     default: throw audio_device_exception("ASIO native sample type not supported: " + _sample_type);
     }
diff --git a/include/audio_backend/__asio_sample.h b/include/audio_backend/__asio_sample.h
index 67dcd1f..8908765 100644
--- a/include/audio_backend/__asio_sample.h
+++ b/include/audio_backend/__asio_sample.h
@@ -16,22 +16,33 @@ class __asio_sample
 public:
   __asio_sample() = default;
   explicit __asio_sample(_SampleType value)
-    : value{ value }
+    : _value{ value }
   {}
+
+  template <typename _IntegralType = _SampleType,
+            enable_if_t<is_integral<_IntegralType>::value, int> = 0>
   explicit __asio_sample(float value)
     : __asio_sample(static_cast<_SampleType>(value * static_cast<double>(numeric_limits<_SampleType>::max())))
   {}
 
   int32_t int_value() const {
-    return value;
+    return _value;
+  }
+
+  template <typename _IntegralType = _SampleType,
+            enable_if_t<is_integral<_IntegralType>::value, int> = 0>
+  float float_value() const {
+    return static_cast<float>(_value) / numeric_limits<_SampleType>::max();
   }
 
+  template <typename _FloatType = _SampleType,
+            enable_if_t<is_floating_point<_FloatType>::value, int> = 0>
   float float_value() const {
-    return static_cast<float>(value) / numeric_limits<_SampleType>::max();
+    return static_cast<float>(_value);
   }
 
 private:
-  _SampleType value;
+  _SampleType _value;
 };
 
 struct packed24_t{};

From 64d4f54de19be67020e8e58c44f77ef948322f34 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Wed, 5 Jun 2019 21:35:54 +0100
Subject: [PATCH 50/97] Clarify intent of ASIOChannelInfo initialization

---
 include/audio_backend/__asio_audio_device.h | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 471532d..a0e0389 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -237,7 +237,7 @@ class audio_device final {
     case 0: set_buffers_as_default_size_only(); break;
     }
 
-    ASIOChannelInfo info{0, _num_inputs > 0};
+    ASIOChannelInfo info{0, is_input()};
     _asio->getChannelInfo(&info);
     _sample_type = info.type;
   }
@@ -371,8 +371,7 @@ class audio_device final {
     }
   }
 
-  static void buffer_switch(long index, ASIOBool)
-  {
+  static void buffer_switch(long index, ASIOBool) {
     instance()->on_buffer_switch(index);
   }
 

From 3fe73a69954b180650743c251f6b059c9d990f3a Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sat, 8 Jun 2019 16:30:02 +0100
Subject: [PATCH 51/97] Return false if start is called before client has
 connected

---
 include/audio_backend/__asio_audio_device.h | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index a0e0389..c361819 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -144,6 +144,9 @@ class audio_device final {
   }
 
   bool start() {
+    if (_asio_buffers.empty()) {
+      return false;
+    }
     instance(this);
     _sample_position = 0;
     const auto result = _asio->start();

From a00799676a5cb6f0992e6bfb9b3d4c3814b71e70 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sun, 9 Jun 2019 23:14:04 +0100
Subject: [PATCH 52/97] Do not assert when ASIO::init fails, expected if ASIO
 device not present

---
 include/audio_backend/__asio_audio_device.h | 40 +++++++++++++--------
 1 file changed, 25 insertions(+), 15 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index c361819..ffcf845 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -36,10 +36,10 @@ class audio_device final {
 public:
   using device_id_t = int;
 
-  explicit audio_device(device_id_t id, string name, CLSID class_id, audio_direction direction)
-    : _name(name), _id(id)
+  explicit audio_device(device_id_t id, string name, IASIO* asio, audio_direction direction)
+    : _name(name), _id(id), _asio(asio)
   {
-    prepare_asio(class_id, direction);
+    prepare_asio(direction);
   }
 
   ~audio_device() {
@@ -196,14 +196,7 @@ class audio_device final {
   }
 
 private:
-  void prepare_asio(const CLSID class_id, const audio_direction direction) {
-    const auto result = CoCreateInstance(class_id, nullptr, CLSCTX_INPROC_SERVER, class_id, reinterpret_cast<void**>(&_asio));
-    if (result) {
-      throw audio_device_exception("Failed to open ASIO driver: 0x" + result);
-    }
-    if (!_asio->init(nullptr)) {
-      return;
-    }
+  void prepare_asio(const audio_direction direction) {
 
     set_callbacks();
     query_io(direction);
@@ -218,7 +211,7 @@ class audio_device final {
   }
 
   void query_io(const audio_direction direction) {
-    const auto result = _asio->getChannels(&_num_inputs, &_num_outputs);
+    auto result = _asio->getChannels(&_num_inputs, &_num_outputs);
 
     if (result != ASE_OK) {
       return;
@@ -232,7 +225,11 @@ class audio_device final {
     long min;
     long max;
     long granularity;
-    _asio->getBufferSize(&min, &max, &_buffer_size, &granularity);
+    result = _asio->getBufferSize(&min, &max, &_buffer_size, &granularity);
+
+    if (result != ASE_OK) {
+      return;
+    }
 
     switch (granularity) {
     default: set_buffers(min, max, granularity); break;
@@ -240,6 +237,8 @@ class audio_device final {
     case 0: set_buffers_as_default_size_only(); break;
     }
 
+    set_buffer_size_frames(_buffer_size);
+
     ASIOChannelInfo info{0, is_input()};
     _asio->getChannelInfo(&info);
     _sample_type = info.type;
@@ -270,7 +269,7 @@ class audio_device final {
         _sample_rates.push_back(sample_rate);
       }
     }
-    if (0 == get_sample_rate()) {
+    if (0 == get_sample_rate() && !_sample_rates.empty()) {
       set_sample_rate(_sample_rates[0]);
     }
   }
@@ -550,7 +549,18 @@ class __asio_devices {
       CLSID class_id;
       CLSIDFromString(CComBSTR(clsid.c_str()), &class_id);
 
-      auto device = audio_device{index++, name, class_id, direction};
+      CComPtr<IASIO> asio;
+      const auto result = CoCreateInstance(class_id, nullptr, CLSCTX_INPROC_SERVER, class_id, reinterpret_cast<void**>(&asio));
+      if (result) {
+        throw audio_device_exception("Failed to open ASIO driver: 0x" + result);
+      }
+
+      if (!asio->init(nullptr)) {
+        // Failed call to init, device not connected
+        continue;
+      }
+
+      auto device = audio_device{index++, name, asio, direction};
       if (is_required(device, direction)) {
         devices.push_front(move(device));
       }

From da5090ece1da0f7211f541e4ca6decb612a0d33f Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Mon, 10 Jun 2019 18:55:07 +0100
Subject: [PATCH 53/97] Rename __asio_backend.h

---
 include/audio                                                   | 2 +-
 include/audio_backend/{__windows_backend.h => __asio_backend.h} | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename include/audio_backend/{__windows_backend.h => __asio_backend.h} (100%)

diff --git a/include/audio b/include/audio
index 8cea260..1f56f45 100644
--- a/include/audio
+++ b/include/audio
@@ -21,7 +21,7 @@
 #ifdef __APPLE__
   #include <audio_backend/__coreaudio_backend.h>
 #elif defined _WIN32
-  #include <audio_backend/__windows_backend.h>
+  #include <audio_backend/__asio_backend.h>
 #else
   #include <audio_backend/__null_backend.h>
 #endif // __APPLE__
diff --git a/include/audio_backend/__windows_backend.h b/include/audio_backend/__asio_backend.h
similarity index 100%
rename from include/audio_backend/__windows_backend.h
rename to include/audio_backend/__asio_backend.h

From b3fdb8f6b9374db50368619853a4df62d1e13bcf Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Mon, 10 Jun 2019 19:56:47 +0100
Subject: [PATCH 54/97] Use Guy's template trick to avoid tcb namespace scoping

Use template<class ...> as per Specification-Style-Guidelines
---
 include/audio                               | 2 ++
 include/audio_backend/__asio_audio_device.h | 6 ++----
 include/audio_backend/__coreaudio_backend.h | 6 ++----
 3 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/include/audio b/include/audio
index 1f56f45..1a86347 100644
--- a/include/audio
+++ b/include/audio
@@ -9,6 +9,8 @@
 
 // TODO: this is a temporary measure until std::span becomes available
 #include "cpp/span.hpp"
+template<class ElementType, std::ptrdiff_t Extent = TCB_SPAN_NAMESPACE_NAME::dynamic_extent>
+using span = TCB_SPAN_NAMESPACE_NAME::span<ElementType, Extent>;
 
 #define _LIBSTDAUDIO_NAMESPACE std::experimental
 
diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index ffcf845..d6db838 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -81,8 +81,7 @@ class audio_device final {
     return sample_rate;
   }
 
-  // TODO: remove tcb scope when std::span is used
-  tcb::span<const sample_rate_t> get_supported_sample_rates() const noexcept {
+  span<const sample_rate_t> get_supported_sample_rates() const noexcept {
     return _sample_rates;
   }
 
@@ -97,8 +96,7 @@ class audio_device final {
     return _buffer_size;
   }
 
-  // TODO: remove tcb scope when std::span is used
-  tcb::span<const buffer_size_t> get_supported_buffer_sizes_frames() const noexcept {
+  span<const buffer_size_t> get_supported_buffer_sizes_frames() const noexcept {
     return _buffer_sizes;
   }
 
diff --git a/include/audio_backend/__coreaudio_backend.h b/include/audio_backend/__coreaudio_backend.h
index 740e209..43dcf3e 100644
--- a/include/audio_backend/__coreaudio_backend.h
+++ b/include/audio_backend/__coreaudio_backend.h
@@ -137,8 +137,7 @@ class audio_device {
     return sample_rate;
   }
 
-  // TODO: remove tcb namespace when std::span is used
-  tcb::span<const sample_rate_t> get_supported_sample_rates() const noexcept {
+  span<const sample_rate_t> get_supported_sample_rates() const noexcept {
     assert(!_supported_sample_rates.empty());
     return {
       _supported_sample_rates.data(),
@@ -184,8 +183,7 @@ class audio_device {
     return buffer_size_frames;
   }
 
-  // TODO: remove tcb namespace when std::byte is used
-  tcb::span<const buffer_size_t> get_supported_buffer_sizes_frames() const noexcept {
+  span<const buffer_size_t> get_supported_buffer_sizes_frames() const noexcept {
     assert(!_supported_buffer_sizes.empty());
     return {
       _supported_buffer_sizes.data(),

From 87dc8b74fd46c7f818aa7fb7549e19d9a0549d38 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Mon, 10 Jun 2019 20:37:07 +0100
Subject: [PATCH 55/97] Use raw string literal for reg key name

---
 include/audio_backend/__asio_audio_device.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index d6db838..cf66b1c 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -481,7 +481,7 @@ class __reg_key_reader final
     RegQueryValueExA(_key, name, nullptr, nullptr, nullptr, &size);
 
     string value(size + 1, 0);
-    RegQueryValueExA(_key, name, nullptr, nullptr, LPBYTE(value.data()), &size);
+    RegQueryValueExA(_key, name, nullptr, nullptr, reinterpret_cast<LPBYTE>(value.data()), &size);
 
     return value;
   }
@@ -533,7 +533,7 @@ class __asio_devices {
   audio_device_list enumerate(audio_direction direction) const {
     audio_device_list devices;
 
-    __reg_key_reader asio_reg(HKEY_LOCAL_MACHINE, "software\\asio");
+    __reg_key_reader asio_reg(HKEY_LOCAL_MACHINE, R"(software\asio)");
 
     int index = 0;
     for (const auto& name : asio_reg.subkeys()) {

From 9056a6f8422d9918fe243f628b528b1649fc7c96 Mon Sep 17 00:00:00 2001
From: Andy Saul <andycsaul@gmail.com>
Date: Tue, 11 Jun 2019 08:05:55 +0100
Subject: [PATCH 56/97] Reset ASIO back-pointer using optional device pointer

This means that different ASIO devices can be used in the lifetime of
the process. However, it is still not possible to use more than one
ASIO driver concurrently.
---
 include/audio_backend/__asio_audio_device.h | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index cf66b1c..d142a3c 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -47,6 +47,7 @@ class audio_device final {
     if (!_asio_buffers.empty()) {
       _asio->disposeBuffers();
     }
+    instance(nullptr);
   }
 
   string_view name() const noexcept {
@@ -427,8 +428,11 @@ class audio_device final {
   vector<ASIOBufferInfo> _asio_buffers;
   ASIOCallbacks _asio_callbacks;
 
-  static audio_device* instance(audio_device* d = nullptr) {
-    static audio_device* device = d;
+  static audio_device* instance(optional<audio_device*> new_device = {}) {
+    static audio_device* device = nullptr;
+    if (new_device.has_value()) {
+      device = *new_device;
+    }
     return device;
   }
 };

From 88ec5cb944dca5f1487cbf35920f7b9cdd8ae6c9 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Thu, 6 Jun 2019 21:08:32 +0100
Subject: [PATCH 57/97] Add trompeloeil framework & mock-out ASIO driver

---
 include/audio_backend/__asio_audio_device.h |    4 +-
 test/asio_test.cpp                          |   31 +
 test/catch/trompeloeil.hpp                  |   50 +
 test/trompeloeil.hpp                        | 4901 +++++++++++++++++++
 4 files changed, 4984 insertions(+), 2 deletions(-)
 create mode 100644 test/catch/trompeloeil.hpp
 create mode 100644 test/trompeloeil.hpp

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index d142a3c..10c640e 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -210,7 +210,7 @@ class audio_device final {
   }
 
   void query_io(const audio_direction direction) {
-    auto result = _asio->getChannels(&_num_inputs, &_num_outputs);
+    const auto result = _asio->getChannels(&_num_inputs, &_num_outputs);
 
     if (result != ASE_OK) {
       return;
@@ -268,7 +268,7 @@ class audio_device final {
         _sample_rates.push_back(sample_rate);
       }
     }
-    if (0 == get_sample_rate() && !_sample_rates.empty()) {
+    if (0 == get_sample_rate()) {
       set_sample_rate(_sample_rates[0]);
     }
   }
diff --git a/test/asio_test.cpp b/test/asio_test.cpp
index 94e7b97..febdbea 100644
--- a/test/asio_test.cpp
+++ b/test/asio_test.cpp
@@ -6,6 +6,8 @@
 #include <audio>
 #include <array>
 #include "catch/catch.hpp"
+#include "catch/trompeloeil.hpp"
+#include "trompeloeil.hpp"
 
 using namespace std::experimental;
 
@@ -83,3 +85,32 @@ TEST_CASE("Converts integer samples to floating point samples", "[asio]")
     CHECK(Approx(minus_half).epsilon(0.0001f) == -0.5f);
   }
 }
+
+class mock_asio : public trompeloeil::mock_interface<IASIO>
+{
+public:
+  MAKE_MOCK2(QueryInterface, long(const IID&, void**), override);
+  IMPLEMENT_MOCK0(AddRef);
+  IMPLEMENT_MOCK0(Release);
+  IMPLEMENT_MOCK1(init);
+  IMPLEMENT_MOCK1(getDriverName);
+  IMPLEMENT_MOCK0(getDriverVersion);
+  IMPLEMENT_MOCK1(getErrorMessage);
+  IMPLEMENT_MOCK0(start);
+  IMPLEMENT_MOCK0(stop);
+  IMPLEMENT_MOCK2(getChannels);
+  IMPLEMENT_MOCK2(getLatencies);
+  IMPLEMENT_MOCK4(getBufferSize);
+  IMPLEMENT_MOCK1(canSampleRate);
+  IMPLEMENT_MOCK1(getSampleRate);
+  IMPLEMENT_MOCK1(setSampleRate);
+  IMPLEMENT_MOCK2(getClockSources);
+  IMPLEMENT_MOCK1(setClockSource);
+  IMPLEMENT_MOCK2(getSamplePosition);
+  IMPLEMENT_MOCK1(getChannelInfo);
+  IMPLEMENT_MOCK4(createBuffers);
+  IMPLEMENT_MOCK0(disposeBuffers);
+  IMPLEMENT_MOCK0(controlPanel);
+  IMPLEMENT_MOCK2(future);
+  IMPLEMENT_MOCK0(outputReady);
+};
diff --git a/test/catch/trompeloeil.hpp b/test/catch/trompeloeil.hpp
new file mode 100644
index 0000000..4747eec
--- /dev/null
+++ b/test/catch/trompeloeil.hpp
@@ -0,0 +1,50 @@
+/*
+ * Trompeloeil C++ mocking framework
+ *
+ * Copyright Björn Fahller 2014-2019
+ *
+ *  Use, modification and distribution is subject to the
+ *  Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at
+ *  http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Project home: https://github.com/rollbear/trompeloeil
+ */
+
+
+#ifndef TROMPELOEIL_CATCH2_HPP_
+#define TROMPELOEIL_CATCH2_HPP_
+
+#ifndef CATCH_VERSION_MAJOR
+#error "<catch.hpp> must be included before <catch2/trompeloeil.hpp>"
+#endif
+
+#include "../trompeloeil.hpp"
+
+namespace trompeloeil
+{
+  template <>
+  inline void reporter<specialized>::send(
+    severity s,
+    const char* file,
+    unsigned long line,
+    const char* msg)
+  {
+    std::ostringstream os;
+    if (line) os << file << ':' << line << '\n';
+    os << msg;
+    auto failure = os.str();
+    if (s == severity::fatal)
+    {
+      FAIL(failure);
+    }
+    else
+    {
+      CAPTURE(failure);
+      CHECK(failure.empty());
+    }
+  }
+}
+
+
+#endif //TROMPELOEIL_CATCH2_HPP_
diff --git a/test/trompeloeil.hpp b/test/trompeloeil.hpp
new file mode 100644
index 0000000..9301931
--- /dev/null
+++ b/test/trompeloeil.hpp
@@ -0,0 +1,4901 @@
+/*
+ * Trompeloeil C++ mocking framework
+ *
+ * Copyright Björn Fahller 2014-2019
+ * Copyright (C) 2017, 2018 Andrew Paxie
+ *
+ *  Use, modification and distribution is subject to the
+ *  Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at
+ *  http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Project home: https://github.com/rollbear/trompeloeil
+ */
+
+#ifndef TROMPELOEIL_HPP_
+#define TROMPELOEIL_HPP_
+
+
+ // trompe l'oeil noun    (Concise Encyclopedia)
+ // Style of representation in which a painted object is intended
+ // to deceive the viewer into believing it is the object itself...
+
+ // project home: https://github.com/rollbear/trompeloeil
+
+
+ // Deficiencies and missing features
+ // * Mocking function templates is not supported
+ // * If a macro kills a kitten, this threatens extinction of all felines!
+
+#if defined(_MSC_VER)
+
+#  define TROMPELOEIL_NORETURN __declspec(noreturn)
+
+#  if (!defined(__cplusplus) || _MSC_VER < 1900)
+#    error requires C++ in Visual Studio 2015 RC or later
+#  endif
+
+#else
+
+#  define TROMPELOEIL_NORETURN [[noreturn]]
+
+#  if (!defined(__cplusplus) || __cplusplus < 201103L)
+#    error requires C++11 or higher
+#  endif
+
+#endif
+
+#if defined(__clang__)
+
+#  define TROMPELOEIL_CLANG 1
+#  define TROMPELOEIL_GCC 0
+#  define TROMPELOEIL_MSVC 0
+
+#  define TROMPELOEIL_CLANG_VERSION \
+  (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__)
+
+#  define TROMPELOEIL_GCC_VERSION 0
+
+#  define TROMPELOEIL_CPLUSPLUS __cplusplus
+
+#elif defined(__GNUC__)
+
+#  define TROMPELOEIL_CLANG 0
+#  define TROMPELOEIL_GCC 1
+#  define TROMPELOEIL_MSVC 0
+
+#  define TROMPELOEIL_CLANG_VERSION 0
+#  define TROMPELOEIL_GCC_VERSION \
+  (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
+
+#  define TROMPELOEIL_CPLUSPLUS __cplusplus
+
+#elif defined(_MSC_VER)
+
+#  define TROMPELOEIL_CLANG 0
+#  define TROMPELOEIL_GCC 0
+#  define TROMPELOEIL_MSVC 1
+
+#  define TROMPELOEIL_CLANG_VERSION 0
+#  define TROMPELOEIL_GCC_VERSION 0
+
+#  if defined(_MSVC_LANG)
+
+    // Compiler is at least Microsoft Visual Studio 2015 Update 3.
+#    define TROMPELOEIL_CPLUSPLUS _MSVC_LANG
+
+#  else /* defined(_MSVC_LANG) */
+
+    /*
+     * This version of Microsoft Visual C++ is released
+     * in a version of Microsoft Visual Studio between
+     * 2015 RC and less than 2015 Update 3.
+     *
+     * It is an amalgam of C++ versions, with no provision
+     * to specify C++11 mode.
+     *
+     * It also has a __cplusplus macro stuck at 199711L with
+     * no way to change it, such as /Zc:__cplusplus.
+     *
+     * Assume the C++14 code path, but don't promise that it is a
+     * fully conforming implementation of C++14 either.
+     * Hence a value of 201401L, which less than 201402L,
+     * the standards conforming value of __cplusplus.
+     */
+#    define TROMPELOEIL_CPLUSPLUS 201401L
+
+#  endif /* !defined(_MSVC_LANG) */
+
+#endif
+
+#include <tuple>
+#include <iomanip>
+#include <sstream>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <cstring>
+#include <regex>
+#include <mutex>
+#include <atomic>
+#include <initializer_list>
+#include <type_traits>
+#include <utility>
+
+
+#ifdef TROMPELOEIL_SANITY_CHECKS
+#include <cassert>
+#define TROMPELOEIL_ASSERT(x) assert(x)
+#else
+#define TROMPELOEIL_ASSERT(x) do {} while (false)
+#endif
+
+#define TROMPELOEIL_IDENTITY(...) __VA_ARGS__ // work around stupid MS VS2015 RC bug
+
+#define TROMPELOEIL_ARG16(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15, ...) _15
+
+#define TROMPELOEIL_COUNT(...)                                                 \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_ARG16(__VA_ARGS__,                          \
+                                         15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0))
+
+#define TROMPELOEIL_CONCAT_(x, y) x ## y
+#define TROMPELOEIL_CONCAT(x, y) TROMPELOEIL_CONCAT_(x, y)
+
+#define TROMPELOEIL_INIT_WITH_STR15(base, x, ...)                              \
+  base{#x, x}, TROMPELOEIL_INIT_WITH_STR14(base, __VA_ARGS__)
+
+#define TROMPELOEIL_INIT_WITH_STR14(base, x, ...)                              \
+  base{#x, x}, TROMPELOEIL_INIT_WITH_STR13(base, __VA_ARGS__)
+
+#define TROMPELOEIL_INIT_WITH_STR13(base, x, ...)                              \
+  base{#x, x}, TROMPELOEIL_INIT_WITH_STR12(base, __VA_ARGS__)
+
+#define TROMPELOEIL_INIT_WITH_STR12(base, x, ...)                              \
+  base{#x, x}, TROMPELOEIL_INIT_WITH_STR11(base, __VA_ARGS__)
+
+#define TROMPELOEIL_INIT_WITH_STR11(base, x, ...)                              \
+  base{#x, x}, TROMPELOEIL_INIT_WITH_STR10(base, __VA_ARGS__)
+
+#define TROMPELOEIL_INIT_WITH_STR10(base, x, ...)                              \
+  base{#x, x}, TROMPELOEIL_INIT_WITH_STR9(base, __VA_ARGS__)
+
+#define TROMPELOEIL_INIT_WITH_STR9(base, x, ...)                               \
+  base{#x, x}, TROMPELOEIL_INIT_WITH_STR8(base, __VA_ARGS__)
+
+#define TROMPELOEIL_INIT_WITH_STR8(base, x, ...)                               \
+  base{#x, x}, TROMPELOEIL_INIT_WITH_STR7(base, __VA_ARGS__)
+
+#define TROMPELOEIL_INIT_WITH_STR7(base, x, ...)                               \
+  base{#x, x}, TROMPELOEIL_INIT_WITH_STR6(base, __VA_ARGS__)
+
+#define TROMPELOEIL_INIT_WITH_STR6(base, x, ...)                               \
+  base{#x, x}, TROMPELOEIL_INIT_WITH_STR5(base, __VA_ARGS__)
+
+#define TROMPELOEIL_INIT_WITH_STR5(base, x, ...)                               \
+  base{#x, x}, TROMPELOEIL_INIT_WITH_STR4(base, __VA_ARGS__)
+
+#define TROMPELOEIL_INIT_WITH_STR4(base, x, ...)                               \
+  base{#x, x}, TROMPELOEIL_INIT_WITH_STR3(base, __VA_ARGS__)
+
+#define TROMPELOEIL_INIT_WITH_STR3(base, x, ...)                               \
+  base{#x, x}, TROMPELOEIL_INIT_WITH_STR2(base, __VA_ARGS__)
+
+#define TROMPELOEIL_INIT_WITH_STR2(base, x, ...)                               \
+  base{#x, x}, TROMPELOEIL_INIT_WITH_STR1(base, __VA_ARGS__)
+
+#define TROMPELOEIL_INIT_WITH_STR1(base, x)                                    \
+  base{#x, x}
+
+#define TROMPELOEIL_INIT_WITH_STR0(base)
+
+#define TROMPELOEIL_INIT_WITH_STR(base, ...)                                   \
+  TROMPELOEIL_CONCAT(TROMPELOEIL_INIT_WITH_STR,                                \
+                     TROMPELOEIL_COUNT(__VA_ARGS__))(base, __VA_ARGS__)
+
+#define TROMPELOEIL_PARAM_LIST15(func_type)                                    \
+  TROMPELOEIL_PARAM_LIST14(func_type),                                         \
+  ::trompeloeil::param_list_t<func_type, 14> p15
+
+#define TROMPELOEIL_PARAM_LIST14(func_type)                                    \
+  TROMPELOEIL_PARAM_LIST13(func_type),                                         \
+  ::trompeloeil::param_list_t<func_type, 13> p14
+
+#define TROMPELOEIL_PARAM_LIST13(func_type)                                    \
+  TROMPELOEIL_PARAM_LIST12(func_type),                                         \
+  ::trompeloeil::param_list_t<func_type, 12> p13
+
+#define TROMPELOEIL_PARAM_LIST12(func_type)                                    \
+  TROMPELOEIL_PARAM_LIST11(func_type),                                         \
+  ::trompeloeil::param_list_t<func_type, 11> p12
+
+#define TROMPELOEIL_PARAM_LIST11(func_type)                                    \
+  TROMPELOEIL_PARAM_LIST10(func_type),                                         \
+  ::trompeloeil::param_list_t<func_type, 10> p11
+
+#define TROMPELOEIL_PARAM_LIST10(func_type)                                    \
+  TROMPELOEIL_PARAM_LIST9(func_type),                                          \
+  ::trompeloeil::param_list_t<func_type, 9> p10
+
+#define TROMPELOEIL_PARAM_LIST9(func_type)                                     \
+  TROMPELOEIL_PARAM_LIST8(func_type),                                          \
+  ::trompeloeil::param_list_t<func_type, 8> p9
+
+#define TROMPELOEIL_PARAM_LIST8(func_type)                                     \
+  TROMPELOEIL_PARAM_LIST7(func_type),                                          \
+  ::trompeloeil::param_list_t<func_type, 7> p8
+
+#define TROMPELOEIL_PARAM_LIST7(func_type)                                     \
+  TROMPELOEIL_PARAM_LIST6(func_type),                                          \
+  ::trompeloeil::param_list_t<func_type, 6> p7
+
+#define TROMPELOEIL_PARAM_LIST6(func_type)                                     \
+  TROMPELOEIL_PARAM_LIST5(func_type),                                          \
+  ::trompeloeil::param_list_t<func_type, 5> p6
+
+#define TROMPELOEIL_PARAM_LIST5(func_type)                                     \
+  TROMPELOEIL_PARAM_LIST4(func_type),                                          \
+    ::trompeloeil::param_list_t<func_type, 4> p5
+
+#define TROMPELOEIL_PARAM_LIST4(func_type)                                     \
+  TROMPELOEIL_PARAM_LIST3(func_type),                                          \
+    ::trompeloeil::param_list_t<func_type, 3> p4
+
+#define TROMPELOEIL_PARAM_LIST3(func_type)                                     \
+  TROMPELOEIL_PARAM_LIST2(func_type),                                          \
+  ::trompeloeil::param_list_t<func_type, 2> p3
+
+#define TROMPELOEIL_PARAM_LIST2(func_type)                                     \
+  TROMPELOEIL_PARAM_LIST1(func_type),                                          \
+  ::trompeloeil::param_list_t<func_type, 1> p2
+
+#define TROMPELOEIL_PARAM_LIST1(func_type)                                     \
+  ::trompeloeil::param_list_t<func_type, 0> p1
+
+#define TROMPELOEIL_PARAM_LIST0(func_type)
+
+#define TROMPELOEIL_PARAM_LIST(num, func_type)                                 \
+  TROMPELOEIL_CONCAT(TROMPELOEIL_PARAM_LIST, num)(func_type)
+
+
+#define TROMPELOEIL_PARAMS15 TROMPELOEIL_PARAMS14, p15
+#define TROMPELOEIL_PARAMS14 TROMPELOEIL_PARAMS13, p14
+#define TROMPELOEIL_PARAMS13 TROMPELOEIL_PARAMS12, p13
+#define TROMPELOEIL_PARAMS12 TROMPELOEIL_PARAMS11, p12
+#define TROMPELOEIL_PARAMS11 TROMPELOEIL_PARAMS10, p11
+#define TROMPELOEIL_PARAMS10 TROMPELOEIL_PARAMS9,  p10
+#define TROMPELOEIL_PARAMS9  TROMPELOEIL_PARAMS8,  p9
+#define TROMPELOEIL_PARAMS8  TROMPELOEIL_PARAMS7,  p8
+#define TROMPELOEIL_PARAMS7  TROMPELOEIL_PARAMS6,  p7
+#define TROMPELOEIL_PARAMS6  TROMPELOEIL_PARAMS5,  p6
+#define TROMPELOEIL_PARAMS5  TROMPELOEIL_PARAMS4,  p5
+#define TROMPELOEIL_PARAMS4  TROMPELOEIL_PARAMS3,  p4
+#define TROMPELOEIL_PARAMS3  TROMPELOEIL_PARAMS2,  p3
+#define TROMPELOEIL_PARAMS2  TROMPELOEIL_PARAMS1,  p2
+#define TROMPELOEIL_PARAMS1  ,                     p1
+#define TROMPELOEIL_PARAMS0
+
+#define TROMPELOEIL_PARAMS(num) TROMPELOEIL_CONCAT(TROMPELOEIL_PARAMS, num)
+
+#if defined(__cxx_rtti) || defined(__GXX_RTTI) || defined(_CPPRTTI)
+#  define TROMPELOEIL_TYPE_ID_NAME(x) typeid(x).name()
+#else
+#  define TROMPELOEIL_TYPE_ID_NAME(x) "object"
+#endif
+
+#if (TROMPELOEIL_CPLUSPLUS == 201103L)
+
+#define TROMPELOEIL_DECLTYPE_AUTO \
+  auto
+
+#define TROMPELOEIL_TRAILING_RETURN_TYPE(return_type) \
+  -> return_type
+
+#else /* (TROMPELOEIL_CPLUSPLUS == 201103L) */
+
+#define TROMPELOEIL_DECLTYPE_AUTO \
+  decltype(auto)
+
+#define TROMPELOEIL_TRAILING_RETURN_TYPE(return_type) \
+  /**/
+
+#endif /* !(TROMPELOEIL_CPLUSPLUS == 201103L) */
+
+  static constexpr bool trompeloeil_movable_mock = false;
+
+namespace trompeloeil
+{
+  template <typename T>
+  struct identity_type
+  {
+    using type = T;
+  };
+
+  template <typename R, typename C, typename ... Args>
+  identity_type<R(Args...)>
+    nonconst_member_signature(R(C::*)(Args...))
+  {
+    return {};
+  }
+
+  template <typename R, typename C, typename ... Args>
+  identity_type<R(Args...)>
+    const_member_signature(R(C::*)(Args...) const)
+  {
+    return {};
+  }
+
+  template <typename ...>
+  struct void_t_
+  {
+    using type = void;
+  };
+
+  template <typename ... T>
+  using void_t = typename void_t_<T...>::type;
+
+  template <template <typename ...> class, typename, typename ...>
+  struct is_detected_ {
+    using type = std::false_type;
+  };
+
+  template <template <typename ...> class D, typename ... Ts>
+  struct is_detected_<D, void_t<D<Ts...>>, Ts...>
+  {
+    using type = std::true_type;
+  };
+
+  template <template <typename ...> class D, typename ... Ts>
+  using is_detected = typename is_detected_<D, void, Ts...>::type;
+
+# if (TROMPELOEIL_CPLUSPLUS == 201103L)
+
+  namespace detail
+  {
+    /* Implement C++14 features using only C++11 entities. */
+
+    /* <memory> */
+
+    /* Implementation of make_unique is from
+     *
+     * Stephan T. Lavavej, "make_unique (Revision 1),"
+     * ISO/IEC JTC1 SC22 WG21 N3656, 18 April 2013.
+     * Available: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3656.htm
+     * Accessed: 14 June 2017
+     */
+    template <class T>
+    struct _Unique_if
+    {
+      typedef std::unique_ptr<T> _Single_object;
+    };
+
+    template <class T>
+    struct _Unique_if<T[]>
+    {
+      typedef std::unique_ptr<T[]> _Unknown_bound;
+    };
+
+    template <class T, size_t N>
+    struct _Unique_if<T[N]>
+    {
+      typedef void _Known_bound;
+    };
+
+    template <class T, class... Args>
+    typename _Unique_if<T>::_Single_object
+      make_unique(Args&&... args)
+    {
+      return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+    }
+
+    template <class T>
+    typename _Unique_if<T>::_Unknown_bound
+      make_unique(size_t n)
+    {
+      typedef typename std::remove_extent<T>::type U;
+      return std::unique_ptr<T>(new U[n]());
+    }
+
+    template <class T, class... Args>
+    typename _Unique_if<T>::_Known_bound
+      make_unique(Args&&...) = delete;
+
+    /* <type_traits> */
+
+    /* The implementation of these is from
+     *
+     * Walter E. Brown, "TransformationTraits Redux, v2,"
+     * ISO/IEC JTC1 SC22 WG21 N3655, 18 April 2013.
+     * Available: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3655.pdf
+     * Accessed: 2 November 2017
+     *
+     * Minor changes to capitalize template parameter `bool B` has been made.
+     *
+     * See also:
+     * http://en.cppreference.com/w/cpp/types/conditional
+     * http://en.cppreference.com/w/cpp/types/decay
+     * http://en.cppreference.com/w/cpp/types/enable_if
+     * http://en.cppreference.com/w/cpp/types/remove_pointer
+     * http://en.cppreference.com/w/cpp/types/remove_reference
+     * Accessed: 17 May 2017
+     */
+    template <bool B, typename T, typename F>
+    using conditional_t = typename std::conditional<B, T, F>::type;
+
+    template <typename T>
+    using decay_t = typename std::decay<T>::type;
+
+    template <bool B, typename T = void>
+    using enable_if_t = typename std::enable_if<B, T>::type;
+
+    template <typename T>
+    using remove_pointer_t = typename std::remove_pointer<T>::type;
+
+    template <typename T>
+    using remove_reference_t = typename std::remove_reference<T>::type;
+
+    /* <utility> */
+
+    /* This implementation of exchange is from
+     *
+     * Jeffrey Yasskin, "exchange() utility function, revision 3,"
+     * ISO/IEC JTC1 SC22 WG21 N3688, 19 April 2013.
+     * Available: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3668.html
+     * Accessed: 2 November 2017
+     *
+     * See also:
+     * http://en.cppreference.com/w/cpp/utility/exchange
+     * Accessed: 17 May 2017
+     */
+    template<class T, class U = T>
+    inline
+      T
+      exchange(
+        T& obj,
+        U&& new_value)
+    {
+      T old_value = std::move(obj);
+      obj = std::forward<U>(new_value);
+      return old_value;
+    }
+
+    /* integer_sequence and index_sequence implemenations are from
+     *
+     * Jonathan Wakely, "Compile-time integer sequences,"
+     * ISO/IEC JTC1 SC22 WG21 N3658, 18 April 2013.
+     * Available: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3658.html
+     * Accessed: 2 November 2017
+     *
+     * See also:
+     * http://en.cppreference.com/w/cpp/utility/integer_sequence
+     * Accessed: 17 May 2017
+     */
+    template <typename T, T... I>
+    struct integer_sequence
+    {
+      // Replaces a typedef used in the definition found in N3658.
+      using value_type = T;
+
+      static constexpr size_t size() noexcept
+      {
+        return sizeof...(I);
+      }
+    };
+
+    template <size_t... I>
+    using index_sequence = integer_sequence<size_t, I...>;
+
+    /* This implementation of make_integer_sequence is from boost/mp11,
+     *
+     * Copyright 2015, 2017 Peter Dimov
+     *
+     * Distributed under the Boost Software License, Version 1.0.
+     *
+     * Implemented here:
+     *
+     * https://github.com/pdimov/mp11/blob/master/include/boost/
+     *   integer_sequence.hpp
+     * Accessed: 17 May 2017
+     *
+     * (now missing) and here:
+     *
+     * https://github.com/boostorg/mp11/blob/develop/include/boost/
+     *   mp11/integer_sequence.hpp
+     * Accessed: 13 August 2017
+     */
+    namespace impl
+    {
+      // iseq_if_c
+      template <bool C, class T, class E>
+      struct iseq_if_c_impl;
+
+      template <class T, class E>
+      struct iseq_if_c_impl<true, T, E>
+      {
+        using type = T;
+      };
+
+      template <class T, class E>
+      struct iseq_if_c_impl<false, T, E>
+      {
+        using type = E;
+      };
+
+      template <bool C, class T, class E>
+      using iseq_if_c = typename iseq_if_c_impl<C, T, E>::type;
+
+      // iseq_identity
+      template <class T>
+      struct iseq_identity
+      {
+        using type = T;
+      };
+
+      template <class S1, class S2>
+      struct append_integer_sequence;
+
+      template <class T, T... I, T... J>
+      struct append_integer_sequence<integer_sequence<T, I...>, integer_sequence<T, J...>>
+      {
+        using type = integer_sequence<T, I..., (J + sizeof...(I))...>;
+      };
+
+      template <class T, T N>
+      struct make_integer_sequence_impl;
+
+      template <class T, T N>
+      struct make_integer_sequence_impl_
+      {
+      private:
+
+        static_assert(N >= 0, "make_integer_sequence<T, N>: N must not be negative");
+
+        static T const M = N / 2;
+        static T const R = N % 2;
+
+        using S1 = typename make_integer_sequence_impl<T, M>::type;
+        using S2 = typename append_integer_sequence<S1, S1>::type;
+        using S3 = typename make_integer_sequence_impl<T, R>::type;
+        using S4 = typename append_integer_sequence<S2, S3>::type;
+
+      public:
+
+        using type = S4;
+      };
+
+      template <class T, T N>
+      struct make_integer_sequence_impl :
+        iseq_if_c<N == 0,
+        iseq_identity<integer_sequence<T>>,
+        iseq_if_c<N == 1,
+        iseq_identity<integer_sequence<T, 0>>,
+        make_integer_sequence_impl_<T, N>>>
+      {
+      };
+    }
+
+    template<class T, T N>
+    using make_integer_sequence = typename impl::make_integer_sequence_impl<T, N>::type;
+
+    template <size_t N>
+    using make_index_sequence = make_integer_sequence<size_t, N>;
+
+    template <typename... T>
+    using index_sequence_for = make_index_sequence<sizeof...(T)>;
+
+  } /* namespace detail */
+
+# else /* (TROMPELOEIL_CPLUSPLUS == 201103L) */
+
+  /* Only these entities really need to
+   * be available in namespace detail, but
+   * VS 2015 has a problem with this approach.
+   *
+   *  namespace detail {
+   *
+   *  using std::make_unique;
+   *
+   *  using std::conditional_t;
+   *  using std::decay_t;
+   *  using std::enable_if_t;
+   *  using std::remove_pointer_t;
+   *  using std::remove_reference_t;
+   *
+   *  using std::exchange;
+   *  using std::index_sequence;
+   *  using std::index_sequence_for;
+   *  using std::integer_sequence;
+   *  using std::make_index_sequence;
+   *
+   *  }
+   *
+   * Instead, use a namespace alias.
+   */
+  namespace detail = std;
+
+# endif /* !(TROMPELOEIL_CPLUSPLUS == 201103L) */
+
+# if TROMPELOEIL_CPLUSPLUS >= 201703L
+#   if TROMPELOEIL_CLANG && TROMPELOEIL_CLANG_VERSION >= 60000
+
+  // these are mostly added to work around clang++ bugs
+  // https://bugs.llvm.org/show_bug.cgi?id=38033
+  // https://bugs.llvm.org/show_bug.cgi?id=38010
+
+  template <typename T>
+  using move_construct_type = decltype(T(std::declval<T&&>()));
+
+  template <typename T>
+  using copy_construct_type = decltype(T(std::declval<const T&>()));
+
+  template <typename T>
+  using can_move_construct = is_detected<move_construct_type, detail::decay_t<T>>;
+
+  template <typename T>
+  using can_copy_construct = is_detected<copy_construct_type, detail::decay_t<T>>;
+
+#   else
+  template <typename T>
+  using can_move_construct = std::is_move_constructible<T>;
+
+  template <typename T>
+  using can_copy_construct = std::is_copy_constructible<T>;
+#   endif
+
+  template <typename F, typename ... A>
+  using invoke_result_type = decltype(std::declval<F&>()(std::declval<A>()...));
+
+# else
+
+  template <typename T>
+  using can_move_construct = std::is_move_constructible<T>;
+
+  template <typename T>
+  using can_copy_construct = std::is_copy_constructible<T>;
+
+  template <typename F, typename ... A>
+  using invoke_result_type = decltype(std::declval<F&>()(std::declval<A>()...));
+
+# endif
+
+  class specialized;
+
+  template <typename T>
+  using aligned_storage_for =
+    typename std::aligned_storage<sizeof(T), alignof(T)>::type;
+
+  template <typename T = void>
+  std::unique_lock<std::recursive_mutex> get_lock()
+  {
+    // Ugly hack for lifetime of mutex. The statically allocated
+    // recursive_mutex is intentionally leaked, to ensure that the
+    // mutex is available and valid even if the last use is from
+    // the destructor of a global object in a translation unit
+    // without #include <trompeloeil.hpp>
+
+    static aligned_storage_for<std::recursive_mutex> buffer;
+    static auto mutex = new (&buffer) std::recursive_mutex;
+    return std::unique_lock<std::recursive_mutex>{*mutex};
+  }
+
+  template <size_t N, typename T>
+  using conditional_tuple_element
+    = detail::conditional_t<(N < std::tuple_size<T>::value),
+    typename std::tuple_element<N, T>::type,
+    int>;
+
+  template <typename T>
+  struct param_list;
+
+  template <typename R, typename ... P>
+  struct param_list<R(P...)>
+  {
+    static size_t constexpr const size = sizeof...(P);
+    template <size_t N>
+    using type = conditional_tuple_element<N, std::tuple<P...>>;
+  };
+
+  template <typename Sig, size_t N>
+  using param_list_t = typename param_list<Sig>::template type<N>;
+
+  class expectation_violation : public std::logic_error
+  {
+  public:
+    using std::logic_error::logic_error;
+  };
+
+  struct location
+  {
+    location()
+      noexcept
+      : file("")
+      , line(0U)
+    {}
+
+    location(
+      char const* file_,
+      unsigned long line_
+    )
+      noexcept
+      : file{ file_ }
+      , line{ line_ }
+    {}
+
+    char const *file;
+    unsigned long line;
+  };
+
+  inline
+    std::ostream&
+    operator<<(
+      std::ostream& os,
+      const location& loc)
+  {
+    if (loc.line != 0U) os << loc.file << ':' << loc.line;
+    return os;
+  }
+
+  enum class severity { fatal, nonfatal };
+
+  using reporter_func = std::function<void(severity,
+    char const *file,
+    unsigned long line,
+    std::string const &msg)>;
+
+  inline
+    void
+    default_reporter(
+      severity,
+      char const *file,
+      unsigned long line,
+      std::string const &msg)
+  {
+    if (!std::current_exception())
+    {
+      std::stringstream os;
+      os << location{ file, line } << "\n" << msg;
+      throw expectation_violation(os.str());
+    }
+  }
+
+  inline
+    reporter_func&
+    reporter_obj()
+  {
+    static reporter_func obj = default_reporter;
+    return obj;
+  }
+
+  inline
+    reporter_func
+    set_reporter(
+      reporter_func f)
+  {
+    return detail::exchange(reporter_obj(), std::move(f));
+  }
+
+  class tracer;
+
+  inline
+    tracer*&
+    tracer_obj()
+    noexcept
+  {
+    static tracer* ptr = nullptr;
+    return ptr;
+  }
+
+  inline
+    tracer*
+    set_tracer(
+      tracer* obj)
+    noexcept
+  {
+    // std::exchange would be sane here, but it costs compilation time
+    auto& ptr = tracer_obj();
+    auto rv = ptr;
+    ptr = obj;
+    return rv;
+  }
+
+  class tracer
+  {
+  public:
+    virtual
+      void
+      trace(
+        char const *file,
+        unsigned long line,
+        std::string const &call) = 0;
+  protected:
+    tracer() = default;
+    tracer(tracer const&) = delete;
+    tracer& operator=(tracer const&) = delete;
+    virtual
+      ~tracer()
+    {
+      set_tracer(previous);
+    }
+  private:
+    tracer* previous = set_tracer(this);
+  };
+
+  class stream_tracer : public tracer
+  {
+  public:
+    stream_tracer(
+      std::ostream& stream_)
+      : stream(stream_) {}
+    void
+      trace(
+        char const *file,
+        unsigned long line,
+        std::string const &call)
+      override
+    {
+      stream << location{ file, line } << '\n' << call << '\n';
+    }
+  private:
+    std::ostream& stream;
+  };
+
+  class trace_agent;
+
+  template <typename T>
+  struct reporter;
+
+  template <typename T>
+  void
+    send_report(
+      severity s,
+      location loc,
+      std::string const &msg)
+  {
+    reporter<T>::send(s, loc.file, loc.line, msg.c_str());
+  }
+
+  template <typename T>
+  struct reporter
+  {
+    static
+      void
+      send(
+        severity s,
+        char const *file,
+        unsigned long line,
+        char const *msg);
+  };
+
+  template <typename T>
+  void reporter<T>::
+    send(
+      severity s,
+      char const *file,
+      unsigned long line,
+      char const *msg)
+  {
+    reporter_obj()(s, file, line, msg);
+  }
+
+  template <typename ... T>
+  inline
+    constexpr
+    bool
+    ignore(
+      T const& ...)
+    noexcept
+  {
+    return true;
+  }
+
+  struct illegal_argument
+  {
+    template <bool b = false>
+    constexpr
+      illegal_argument const& operator&() const
+    {
+      static_assert(b, "illegal argument");
+      return *this;
+    }
+
+    template <bool b = false>
+    constexpr
+      illegal_argument const& operator*() const
+    {
+      static_assert(b, "illegal argument");
+      return *this;
+    }
+
+    template <typename T, bool b = false>
+    constexpr
+      illegal_argument const& operator=(T const&) const
+    {
+      static_assert(b, "illegal argument");
+      return *this;
+    }
+
+    template <typename T, bool b = false>
+    constexpr
+      operator T() const
+    {
+      static_assert(b, "illegal argument");
+      return {};
+    }
+  };
+
+  struct matcher { };
+
+  struct wildcard : public matcher
+  {
+    // This abomination of constructor seems necessary for g++ 4.9 and 5.1
+    template <typename ... T>
+    constexpr
+      wildcard(
+        T&& ...)
+      noexcept
+    {}
+
+#if (!TROMPELOEIL_GCC) || \
+    (TROMPELOEIL_GCC && TROMPELOEIL_GCC_VERSION >= 40900)
+
+    // g++ 4.8 gives a "conversion from <T> to <U> is ambiguous" error
+    // if this operator is defined.
+    template <typename T,
+      typename = detail::enable_if_t<!std::is_lvalue_reference<T>::value>>
+      operator T && ()
+      const;
+
+#endif
+
+    template <
+      typename T,
+      typename = detail::enable_if_t<
+      can_copy_construct<T>::value
+      || !can_move_construct<T>::value
+      >
+    >
+      operator T&()
+      const;
+
+    template <typename T>
+    constexpr
+      bool
+      matches(
+        T const&)
+      const
+      noexcept
+    {
+      return true;
+    }
+
+    friend
+      std::ostream&
+      operator<<(
+        std::ostream& os,
+        wildcard const&)
+      noexcept
+    {
+      return os << " matching _";
+    }
+  };
+
+  static constexpr wildcard const _{};
+
+
+  template <typename T>
+  using matcher_access = decltype(static_cast<matcher*>(std::declval<typename std::add_pointer<T>::type>()));
+
+  template <typename T>
+  using is_matcher = typename is_detected<matcher_access, T>::type;
+
+  template <typename T>
+  struct typed_matcher : matcher
+  {
+    operator T() const;
+  };
+
+  template <>
+  struct typed_matcher<std::nullptr_t> : matcher
+  {
+    template <typename T, typename = decltype(std::declval<T>() == nullptr)>
+    operator T && () const;
+
+    template <typename T,
+      typename = decltype(std::declval<T>() == nullptr),
+      typename = detail::enable_if_t<can_copy_construct<T>::value>>
+      operator T&()const;
+
+    template <typename T, typename C>
+    operator T C::*() const;
+  };
+
+  template <typename Pred, typename ... T>
+  class duck_typed_matcher : public matcher
+  {
+  public:
+#if (!TROMPELOEIL_GCC) || \
+    (TROMPELOEIL_GCC && TROMPELOEIL_GCC_VERSION >= 40900)
+
+    // g++ 4.8 gives a "conversion from <T> to <U> is ambiguous" error
+    // if this operator is defined.
+    template <typename V,
+      typename = detail::enable_if_t < !is_matcher<V>{} > ,
+      typename = invoke_result_type<Pred, V&&, T... >>
+      operator V && () const;
+
+#endif
+
+    template <typename V,
+      typename = detail::enable_if_t < !is_matcher<V>{} > ,
+      typename = invoke_result_type<Pred, V&, T... >>
+      operator V&() const;
+  };
+
+  template <typename T>
+  using ostream_insertion = decltype(std::declval<std::ostream&>() << std::declval<T>());
+
+  template <typename T>
+  using is_output_streamable = std::integral_constant<bool, is_detected<ostream_insertion, T>::value && !std::is_array<T>::value>;
+
+  struct stream_sentry
+  {
+    stream_sentry(
+      std::ostream& os_)
+      : os(os_)
+      , width(os.width(0))
+      , flags(os.flags(std::ios_base::dec | std::ios_base::left))
+      , fill(os.fill(' '))
+    {  }
+    ~stream_sentry()
+    {
+      os.flags(flags);
+      os.fill(fill);
+      os.width(width);
+    }
+  private:
+    std::ostream& os;
+    std::streamsize width;
+    std::ios_base::fmtflags flags;
+    char fill;
+  };
+
+  template <typename T, typename U>
+  using equality_comparison = decltype((std::declval<T>() == std::declval<U>())
+    ? true
+    : false);
+
+  template <typename T, typename U>
+  using is_equal_comparable = is_detected<equality_comparison, T, U>;
+
+  template <typename T>
+  using is_null_comparable = is_equal_comparable<T, std::nullptr_t>;
+
+  template <typename T>
+  inline
+    constexpr
+    bool
+    is_null(
+      T const &t,
+      std::true_type)
+    noexcept(noexcept(std::declval<const T&>() == nullptr))
+  {
+    return t == nullptr;
+  }
+
+  template <typename T>
+  inline
+    constexpr
+    bool
+    is_null(
+      T const &,
+      std::false_type)
+    noexcept
+  {
+    return false;
+  }
+
+  template <typename T>
+  inline
+    constexpr
+    bool
+    is_null(
+      T const &t)
+  {
+    // g++-4.9 uses C++11 rules for constexpr function, so can't
+    // break this up into smaller bits
+    using tag = std::integral_constant<bool, is_null_comparable<T>::value
+      && !is_matcher<T>::value
+      && !std::is_array<T>::value>;
+
+    return ::trompeloeil::is_null(t, tag{});
+  }
+
+  template <typename T>
+  void
+    print(
+      std::ostream& os,
+      T const &t);
+
+  template <typename T>
+  using iterable = decltype(std::begin(std::declval<T&>()) == std::end(std::declval<T&>()));
+
+  template <typename T>
+  using is_collection = is_detected<iterable, T>;
+
+  template <typename T,
+    bool = is_output_streamable<T>::value,
+    bool = is_collection<detail::remove_reference_t<T>>::value>
+    struct streamer
+  {
+    static
+      void
+      print(
+        std::ostream& os,
+        T const &t)
+    {
+      stream_sentry s(os);
+      os << t;
+    }
+  };
+
+  template <typename ... T>
+  struct streamer<std::tuple<T...>, false, false>
+  {
+    static
+      void
+      print(
+        std::ostream& os,
+        std::tuple<T...> const&  t)
+    {
+      print_tuple(os, t, detail::index_sequence_for<T...>{});
+    }
+    template <size_t ... I>
+    static
+      void
+      print_tuple(
+        std::ostream& os,
+        std::tuple<T...> const& t,
+        detail::index_sequence<I...>)
+    {
+      os << "{ ";
+      const char* sep = "";
+      std::initializer_list<const char*> v{ ((os << sep),
+                                            ::trompeloeil::print(os, std::get<I>(t)),
+                                            (sep = ", "))... };
+      ignore(v);
+      os << " }";
+    }
+  };
+
+  template <typename T, typename U>
+  struct streamer<std::pair<T, U>, false, false>
+  {
+    static
+      void
+      print(
+        std::ostream& os,
+        std::pair<T, U> const& t)
+    {
+      os << "{ ";
+      ::trompeloeil::print(os, t.first);
+      os << ", ";
+      ::trompeloeil::print(os, t.second);
+      os << " }";
+    }
+  };
+
+  template <typename T>
+  struct streamer<T, false, true>
+  {
+    static
+      void
+      print(
+        std::ostream& os,
+        T const& t)
+    {
+      os << "{ ";
+      const char* sep = "";
+      auto const end = std::end(t);
+      for (auto i = std::begin(t); i != end; ++i)
+      {
+        os << sep;
+        ::trompeloeil::print(os, *i);
+        sep = ", ";
+      }
+      os << " }";
+    }
+  };
+
+  template <typename T>
+  struct streamer<T, false, false>
+  {
+    static
+      void
+      print(
+        std::ostream& os,
+        T const &t)
+    {
+      stream_sentry s(os);
+      static const char *linebreak = "\n";
+      os << sizeof(T) << "-byte object={";
+      os << (linebreak + (sizeof(T) <= 8)); // stupid construction silences VS2015 warning
+      os << std::setfill('0') << std::hex;
+      auto p = reinterpret_cast<uint8_t const*>(&t);
+      for (size_t i = 0; i < sizeof(T); ++i)
+      {
+        os << " 0x" << std::setw(2) << unsigned(p[i]);
+        if ((i & 0xf) == 0xf) os << '\n';
+      }
+      os << " }";
+    }
+  };
+
+  template <typename T>
+  void
+    print(
+      std::ostream& os,
+      T const &t)
+  {
+    if (is_null(t))
+    {
+      os << "nullptr";
+    }
+    else
+    {
+      streamer<T>::print(os, t);
+    }
+  }
+
+  inline
+    constexpr
+    auto
+    param_compare_operator(
+      ...)
+    TROMPELOEIL_TRAILING_RETURN_TYPE(const char*)
+  {
+    return " == ";
+  }
+
+  inline
+    constexpr
+    auto
+    param_compare_operator(
+      matcher const*)
+    TROMPELOEIL_TRAILING_RETURN_TYPE(const char*)
+  {
+    return "";
+  }
+
+  template <typename T>
+  void
+    print_expectation(
+      std::ostream& os,
+      T const& t)
+  {
+    os << param_compare_operator(&t);
+    print(os, t);
+    os << '\n';
+  }
+
+  template <typename T>
+  class list_elem
+  {
+  public:
+    list_elem(
+      const list_elem&)
+      = delete;
+
+    list_elem(
+      list_elem &&r)
+      noexcept
+    {
+      *this = std::move(r);
+    }
+
+    list_elem&
+      operator=(
+        list_elem &&r)
+      noexcept
+    {
+      if (this != &r)
+      {
+        next = r.next;
+        prev = &r;
+        r.invariant_check();
+
+        next->prev = this;
+        r.next = this;
+
+        TROMPELOEIL_ASSERT(next->prev == this);
+        TROMPELOEIL_ASSERT(prev->next == this);
+
+        r.unlink();
+
+        TROMPELOEIL_ASSERT(!r.is_linked());
+        invariant_check();
+      }
+      return *this;
+    }
+
+    list_elem&
+      operator=(
+        const list_elem&)
+      = delete;
+
+    virtual
+      ~list_elem()
+    {
+      unlink();
+    }
+
+    void
+      unlink()
+      noexcept
+    {
+      invariant_check();
+      auto n = next;
+      auto p = prev;
+      n->prev = p;
+      p->next = n;
+      next = this;
+      prev = this;
+      invariant_check();
+    }
+
+    void
+      invariant_check()
+      const
+      noexcept
+    {
+#ifdef TROMPELOEIL_SANITY_CHECKS
+      TROMPELOEIL_ASSERT(next->prev == this);
+      TROMPELOEIL_ASSERT(prev->next == this);
+      TROMPELOEIL_ASSERT((next == this) == (prev == this));
+      TROMPELOEIL_ASSERT((prev->next == next) == (next == this));
+      TROMPELOEIL_ASSERT((next->prev == prev) == (prev == this));
+      auto pp = prev;
+      auto nn = next;
+      do {
+        TROMPELOEIL_ASSERT((nn == this) == (pp == this));
+        TROMPELOEIL_ASSERT(nn->next->prev == nn);
+        TROMPELOEIL_ASSERT(nn->prev->next == nn);
+        TROMPELOEIL_ASSERT(pp->next->prev == pp);
+        TROMPELOEIL_ASSERT(pp->prev->next == pp);
+        TROMPELOEIL_ASSERT((nn->next == nn) == (nn == this));
+        TROMPELOEIL_ASSERT((pp->prev == pp) == (pp == this));
+        nn = nn->next;
+        pp = pp->prev;
+      } while (nn != this);
+#endif
+    }
+
+    bool
+      is_linked()
+      const
+      noexcept
+    {
+      invariant_check();
+      return next != this;
+    }
+  protected:
+    list_elem() noexcept = default;
+  public:
+    list_elem* next = this;
+    list_elem* prev = this;
+  };
+
+  class ignore_disposer
+  {
+  protected:
+    template <typename T>
+    TROMPELOEIL_NORETURN
+      void
+      dispose(
+        T*)
+      const
+      noexcept
+    {
+      std::abort(); // must never be called
+    }
+  };
+
+  class delete_disposer
+  {
+  protected:
+    template <typename T>
+    void
+      dispose(
+        T* t)
+      const
+    {
+      delete t;
+    }
+  };
+
+  template <typename T, typename Disposer = ignore_disposer>
+  class list : private list_elem<T>, private Disposer
+  {
+  public:
+    list() noexcept;
+    list(list&&) noexcept;
+    list(const list&) = delete;
+    list& operator=(list&&) noexcept;
+    list& operator=(const list&) = delete;
+    ~list();
+    class iterator;
+    iterator begin() const noexcept;
+    iterator end() const noexcept;
+    iterator push_front(T* t) noexcept;
+    iterator push_back(T* t) noexcept;
+    bool empty() const noexcept { return begin() == end(); }
+  private:
+    using list_elem<T>::invariant_check;
+    using list_elem<T>::next;
+    using list_elem<T>::prev;
+  };
+
+  template <typename T, typename Disposer>
+  class list<T, Disposer>::iterator
+    : public std::iterator<std::bidirectional_iterator_tag, T>
+  {
+    friend class list<T, Disposer>;
+  public:
+    iterator()
+      noexcept
+      : p{ nullptr }
+    {}
+
+    friend
+      bool
+      operator==(
+        iterator const &lh,
+        iterator const &rh)
+      noexcept
+    {
+      return lh.p == rh.p;
+    }
+
+    friend
+      bool
+      operator!=(
+        iterator const &lh,
+        iterator const &rh)
+      noexcept
+    {
+      return !(lh == rh);
+    }
+
+    iterator&
+      operator++()
+      noexcept
+    {
+      p = p->next;
+      return *this;
+    }
+
+    iterator
+      operator++(int)
+      noexcept
+    {
+      auto rv = *this;
+      operator++();
+      return rv;
+    }
+
+    T&
+      operator*()
+      noexcept
+    {
+      return static_cast<T&>(*p);
+    }
+
+    T*
+      operator->()
+      noexcept
+    {
+      return static_cast<T*>(p);
+    }
+
+  private:
+    iterator(
+      list_elem<T> const *t)
+      noexcept
+      : p{ const_cast<list_elem<T>*>(t) }
+    {}
+
+    list_elem<T>* p;
+  };
+
+  template <typename T, typename Disposer>
+  list<T, Disposer>::list() noexcept = default;
+
+  template <typename T, typename Disposer>
+  list<T, Disposer>::list(list&&) noexcept = default;
+
+  template <typename T, typename Disposer>
+  list<T, Disposer>& list<T, Disposer>::operator=(list&&) noexcept = default;
+
+  template <typename T, typename Disposer>
+  list<T, Disposer>::~list()
+  {
+    auto i = this->begin();
+    while (i != this->end())
+    {
+      auto p = i++;
+      Disposer::dispose(&*p);
+    }
+  }
+
+  template <typename T, typename Disposer>
+  auto
+    list<T, Disposer>::begin()
+    const
+    noexcept
+    -> iterator
+  {
+    return { next };
+  }
+
+  template <typename T, typename Disposer>
+  auto
+    list<T, Disposer>::end()
+    const
+    noexcept
+    -> iterator
+  {
+    return { this };
+  }
+
+  template <typename T, typename Disposer>
+  auto
+    list<T, Disposer>::push_front(
+      T* t)
+    noexcept
+    -> iterator
+  {
+    invariant_check();
+    t->next = next;
+    t->prev = this;
+    next->prev = t;
+    next = t;
+    invariant_check();
+    return { t };
+  }
+
+  template <typename T, typename Disposer>
+  auto
+    list<T, Disposer>::push_back(
+      T* t)
+    noexcept
+    -> iterator
+  {
+    invariant_check();
+    t->prev = prev;
+    t->next = this;
+    prev->next = t;
+    prev = t;
+    invariant_check();
+    return { t };
+  }
+
+  class sequence_matcher;
+
+  class sequence_type
+  {
+  public:
+    sequence_type() noexcept = default;
+    sequence_type(sequence_type&&) noexcept = delete;
+    sequence_type(const sequence_type&) = delete;
+    sequence_type& operator=(sequence_type&&) noexcept = delete;
+    sequence_type& operator=(const sequence_type&) = delete;
+    ~sequence_type();
+
+    bool
+      is_completed()
+      const
+      noexcept;
+
+    bool
+      is_first(
+        sequence_matcher const *m)
+      const
+      noexcept;
+
+    void
+      add_last(
+        sequence_matcher *m)
+      noexcept;
+
+    void
+      validate_match(
+        severity s,
+        sequence_matcher const *matcher,
+        char const *seq_name,
+        char const *match_name,
+        location loc)
+      const;
+
+  private:
+    list<sequence_matcher> matchers;
+  };
+
+  class sequence
+  {
+  public:
+    sequence() : obj(new sequence_type) {}
+    sequence_type& operator*() { return *obj; }
+    bool is_completed() const { return obj->is_completed(); }
+  private:
+    std::unique_ptr<sequence_type> obj;
+  };
+
+  class sequence_matcher : public list_elem<sequence_matcher>
+  {
+  public:
+    using init_type = std::pair<char const*, sequence&>;
+    sequence_matcher(
+      char const *exp,
+      location loc,
+      init_type i)
+      noexcept
+      : seq_name(i.first)
+      , exp_name(exp)
+      , exp_loc(loc)
+      , seq(*i.second)
+    {
+      auto lock = get_lock();
+      seq.add_last(this);
+    }
+
+    void
+      validate_match(
+        severity s,
+        char const *match_name,
+        location loc)
+      const
+    {
+      seq.validate_match(s, this, seq_name, match_name, loc);
+    }
+
+    bool
+      is_first()
+      const
+      noexcept
+    {
+      return seq.is_first(this);
+    }
+
+    void
+      retire()
+      noexcept
+    {
+      this->unlink();
+    }
+
+    void
+      print_expectation(std::ostream& os)
+      const
+    {
+      os << exp_name << " at " << exp_loc;
+    }
+
+    char const*
+      sequence_name()
+      noexcept
+    {
+      return seq_name;
+    }
+  private:
+    char const *seq_name;
+    char const *exp_name;
+    location    exp_loc;
+    sequence_type& seq;
+  };
+
+  inline
+    bool
+    sequence_type::is_completed()
+    const
+    noexcept
+  {
+    return matchers.empty();
+  }
+
+  inline
+    bool
+    sequence_type::is_first(
+      sequence_matcher const *m)
+    const
+    noexcept
+  {
+    return !matchers.empty() && &*matchers.begin() == m;
+  }
+
+  inline
+    void
+    sequence_type::validate_match(
+      severity s,
+      sequence_matcher const *matcher,
+      char const* seq_name,
+      char const* match_name,
+      location loc)
+    const
+  {
+    if (is_first(matcher)) return;
+    for (auto& m : matchers)
+    {
+      std::ostringstream os;
+      os << "Sequence mismatch for sequence \"" << seq_name
+        << "\" with matching call of " << match_name
+        << " at " << loc
+        << ". Sequence \"" << seq_name << "\" has ";
+      m.print_expectation(os);
+      os << " first in line\n";
+      send_report<specialized>(s, loc, os.str());
+    }
+  }
+
+  inline
+    sequence_type::~sequence_type()
+  {
+    bool touched = false;
+    std::ostringstream os;
+    while (!matchers.empty())
+    {
+      auto m = matchers.begin();
+      if (!touched)
+      {
+        os << "Sequence expectations not met at destruction of sequence object \""
+          << m->sequence_name() << "\":";
+        touched = true;
+      }
+      os << "\n  missing ";
+      m->print_expectation(os);
+      m->unlink();
+    }
+    if (touched)
+    {
+      os << "\n";
+      send_report<specialized>(severity::nonfatal, location{}, os.str());
+    }
+  }
+
+  inline
+    void
+    sequence_type::add_last(
+      sequence_matcher *m)
+    noexcept
+  {
+    matchers.push_back(m);
+  }
+
+  template <typename T>
+  void can_match_parameter(T&);
+
+  template <typename T>
+  void can_match_parameter(T&&);
+
+  template <typename M>
+  class ptr_deref : public matcher
+  {
+  public:
+    template <typename U,
+      typename = decltype(can_match_parameter<detail::remove_reference_t<decltype(*std::declval<U>())>>(std::declval<M>()))>
+      operator U() const;
+
+    template <typename U>
+    explicit
+      ptr_deref(
+        U&& m_)
+      : m(std::forward<U>(m_))
+    {}
+
+    template <typename U>
+    bool
+      matches(
+        const U& u)
+      const
+      noexcept(noexcept(std::declval<M>().matches(*u)))
+    {
+      return (u != nullptr) && m.matches(*u);
+    }
+
+    friend
+      std::ostream&
+      operator<<(
+        std::ostream& os,
+        ptr_deref<M> const& p)
+    {
+      return os << p.m;
+    }
+  private:
+    M m;
+  };
+
+  template <typename M>
+  class neg_matcher : public matcher
+  {
+  public:
+    template <typename U,
+      typename = decltype(can_match_parameter<detail::remove_reference_t<decltype(std::declval<U>())>>(std::declval<M>()))>
+      operator U() const;
+
+    template <typename U>
+    explicit
+      neg_matcher(
+        U&& m_)
+      : m(std::forward<U>(m_))
+    {}
+
+    template <typename U>
+    bool
+      matches(
+        const U& u)
+      const
+      noexcept(noexcept(!std::declval<M>().matches(u)))
+    {
+      return !m.matches(u);
+    }
+
+    friend
+      std::ostream&
+      operator<<(
+        std::ostream& os,
+        neg_matcher<M> const& p)
+    {
+      return os << p.m;
+    }
+  private:
+    M m;
+  };
+
+  template <typename MatchType, typename Predicate, typename ... ActualType>
+  struct matcher_kind
+  {
+    using type = typed_matcher<MatchType>;
+  };
+
+  template <typename Predicate, typename ... ActualType>
+  struct matcher_kind<wildcard, Predicate, ActualType...>
+  {
+    using type = duck_typed_matcher<Predicate, ActualType...>;
+  };
+
+  template <typename MatchType, typename Predicate, typename ... ActualType>
+  using matcher_kind_t =
+    typename matcher_kind<MatchType, Predicate, ActualType...>::type;
+
+  template <typename Predicate, typename Printer, typename MatcherType, typename ... T>
+  class predicate_matcher
+    : private Predicate
+    , private Printer
+    , public MatcherType
+  {
+  public:
+    template <typename ... U>
+    constexpr
+      predicate_matcher(
+        Predicate&& pred,
+        Printer&& printer,
+        U&& ... v)
+      noexcept(noexcept(std::tuple<T...>(std::declval<U>()...)) && noexcept(Predicate(std::declval<Predicate&&>())) && noexcept(Printer(std::declval<Printer&&>())))
+      : Predicate(std::move(pred))
+      , Printer(std::move(printer))
+      , value(std::forward<U>(v)...)
+    {}
+
+    template <typename V>
+    constexpr
+      bool
+      matches(
+        V&& v)
+      const
+      noexcept(noexcept(std::declval<Predicate const&>()(std::declval<V&&>(), std::declval<const T&>()...)))
+    {
+      return matches_(std::forward<V>(v), detail::make_index_sequence<sizeof...(T)>{});
+    }
+
+    friend
+      std::ostream&
+      operator<<(
+        std::ostream& os,
+        predicate_matcher const& v)
+    {
+      return v.print_(os, detail::make_index_sequence<sizeof...(T)>{});
+    }
+  private:
+    // The below function call operator must be declared to
+    // work around gcc bug 78446
+    //
+    // For some reason microsoft compiler from VS2015 update 3
+    // requires the function call operator to be private to avoid
+    // ambiguities.
+    template <typename ... U>
+    void operator()(U&&...) const = delete;
+
+    template <typename V, size_t ... I>
+    bool matches_(V&& v, detail::index_sequence<I...>) const
+    {
+      return Predicate::operator()(std::forward<V>(v), std::get<I>(value)...);
+    }
+
+    template <size_t ... I>
+    std::ostream& print_(std::ostream& os_, detail::index_sequence<I...>) const
+    {
+      Printer::operator()(os_, std::get<I>(value)...);
+      return os_;
+    }
+
+    std::tuple<T...> value;
+  };
+
+  template <typename MatchType, typename Predicate, typename Printer, typename ... T>
+  using make_matcher_return =
+    predicate_matcher<Predicate,
+    Printer,
+    matcher_kind_t<MatchType, Predicate, detail::decay_t<T>...>,
+    detail::decay_t<T>...>;
+
+  namespace lambdas {
+
+    struct any_predicate
+    {
+      template <typename T>
+      bool
+        operator()(
+          T&&)
+        const
+      {
+        return true;
+      }
+    };
+
+    // The below must be classes/structs to work with VS 2015 update 3
+    // since it doesn't respect the trailing return type declaration on
+    // the lambdas of template deduction context
+
+#define TROMPELOEIL_MK_PRED_BINOP(name, op)                         \
+    struct name {                                                       \
+      template <typename X, typename Y>                                 \
+      auto operator()(X const& x, Y const& y) const -> decltype(x op y) \
+      {                                                                 \
+        ::trompeloeil::ignore(x,y);                                     \
+        return x op y;                                                  \
+      }                                                                 \
+    }
+    TROMPELOEIL_MK_PRED_BINOP(equal, == );
+    TROMPELOEIL_MK_PRED_BINOP(not_equal, != );
+    TROMPELOEIL_MK_PRED_BINOP(less, < );
+    TROMPELOEIL_MK_PRED_BINOP(less_equal, <= );
+    TROMPELOEIL_MK_PRED_BINOP(greater, > );
+    TROMPELOEIL_MK_PRED_BINOP(greater_equal, >= );
+#undef TROMPELOEIL_MK_PRED_BINOP
+
+    // Define `struct` with `operator()` to replace generic lambdas.
+
+    struct any_printer
+    {
+      explicit
+        any_printer(
+          char const* type_name_)
+        : type_name(type_name_)
+      {}
+
+      void
+        operator()(
+          std::ostream& os)
+        const
+      {
+        os << " matching ANY(" << type_name << ")";
+      }
+
+    private:
+      char const* type_name;
+    };
+
+    // These structures replace the `op` printer lambdas.
+
+#define TROMPELOEIL_MK_OP_PRINTER(name, op_string)                  \
+    struct name ## _printer                                             \
+    {                                                                   \
+      template <typename T>                                             \
+      void                                                              \
+      operator()(                                                       \
+        std::ostream& os,                                               \
+        T const& value)                                                 \
+      const                                                             \
+      {                                                                 \
+        os << op_string;                                                \
+        ::trompeloeil::print(os, value);                                \
+      }                                                                 \
+    }
+    TROMPELOEIL_MK_OP_PRINTER(equal, " == ");
+    TROMPELOEIL_MK_OP_PRINTER(not_equal, " != ");
+    TROMPELOEIL_MK_OP_PRINTER(less, " < ");
+    TROMPELOEIL_MK_OP_PRINTER(less_equal, " <= ");
+    TROMPELOEIL_MK_OP_PRINTER(greater, " > ");
+    TROMPELOEIL_MK_OP_PRINTER(greater_equal, " >= ");
+#undef TROMPELOEIL_MK_OP_PRINTER
+
+  }
+
+  template <typename MatchType, typename Predicate, typename Printer, typename ... T>
+  inline
+    make_matcher_return<MatchType, Predicate, Printer, T...>
+    make_matcher(Predicate pred, Printer print, T&& ... t)
+  {
+    return { std::move(pred), std::move(print), std::forward<T>(t)... };
+  }
+
+
+  template <
+    typename T,
+    typename R = make_matcher_return<T, lambdas::any_predicate, lambdas::any_printer>>
+    inline
+    auto
+    any_matcher_impl(char const* type_name, std::false_type)
+    TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+  {
+    return make_matcher<T>(lambdas::any_predicate(), lambdas::any_printer(type_name));
+  }
+
+  template <typename T>
+  wildcard
+    any_matcher_impl(char const*, std::true_type);
+
+  template <typename T>
+  inline
+    auto
+    any_matcher(char const* name)
+    TROMPELOEIL_TRAILING_RETURN_TYPE(decltype(any_matcher_impl<T>(name, std::is_array<T>{})))
+  {
+    static_assert(!std::is_array<T>::value,
+      "array parameter type decays to pointer type for ANY()"
+      " matcher. Please rephrase as pointer instead");
+    return any_matcher_impl<T>(name, std::is_array<T>{});
+  }
+  template <
+    typename T = wildcard,
+    typename V,
+    typename R = make_matcher_return<T, lambdas::equal, lambdas::equal_printer, V>>
+    inline
+    auto
+    eq(
+      V&& v)
+    TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+  {
+    return make_matcher<T>(lambdas::equal(),
+      lambdas::equal_printer(),
+      std::forward<V>(v));
+  }
+
+  template <
+    typename T = wildcard,
+    typename V,
+    typename R = make_matcher_return<T, lambdas::not_equal, lambdas::not_equal_printer, V>>
+    inline
+    auto
+    ne(
+      V&& v)
+    TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+  {
+    return make_matcher<T>(lambdas::not_equal(),
+      lambdas::not_equal_printer(),
+      std::forward<V>(v));
+  }
+
+  template <
+    typename T = wildcard,
+    typename V,
+    typename R = make_matcher_return<T, lambdas::greater_equal, lambdas::greater_equal_printer, V>>
+    inline
+    auto
+    ge(
+      V&& v)
+    TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+  {
+    return make_matcher<T>(lambdas::greater_equal(),
+      lambdas::greater_equal_printer(),
+      std::forward<V>(v));
+  }
+
+  template <
+    typename T = wildcard,
+    typename V,
+    typename R = make_matcher_return<T, lambdas::greater, lambdas::greater_printer, V>>
+    inline
+    auto
+    gt(
+      V&& v)
+    TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+  {
+    return make_matcher<T>(lambdas::greater(),
+      lambdas::greater_printer(),
+      std::forward<V>(v));
+  }
+
+  template <
+    typename T = wildcard,
+    typename V,
+    typename R = make_matcher_return<T, lambdas::less, lambdas::less_printer, V>>
+    inline
+    auto
+    lt(
+      V&& v)
+    TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+  {
+    return make_matcher<T>(lambdas::less(),
+      lambdas::less_printer(),
+      std::forward<V>(v));
+  }
+
+  template <
+    typename T = wildcard,
+    typename V,
+    typename R = make_matcher_return<T, lambdas::less_equal, lambdas::less_equal_printer, V>>
+    inline
+    auto
+    le(
+      V&& v)
+    TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+  {
+    return make_matcher<T>(lambdas::less_equal(),
+      lambdas::less_equal_printer(),
+      std::forward<V>(v));
+  }
+
+  namespace lambdas {
+
+    struct regex_check
+    {
+
+      class string_helper // a vastly simplified string_view type of class
+      {
+      public:
+        string_helper(
+          std::string const& s)
+          noexcept
+          : str(s.c_str())
+        {}
+
+        constexpr
+          string_helper(
+            char const* s)
+          noexcept
+          : str(s)
+        {}
+
+        char const*
+          c_str()
+          const
+          noexcept
+        {
+          return str;
+        }
+      private:
+        char const* str;
+      };
+
+      regex_check(
+        std::regex&& re_,
+        std::regex_constants::match_flag_type match_type_)
+        : re(std::move(re_)),
+        match_type(match_type_)
+      {}
+
+      template <typename T>
+      bool
+        operator()(
+          string_helper str,
+          T const&)
+        const
+      {
+        return !::trompeloeil::is_null(str.c_str())
+          && std::regex_search(str.c_str(), re, match_type);
+      }
+
+    private:
+      std::regex re;
+      std::regex_constants::match_flag_type match_type;
+    };
+
+    struct regex_printer
+    {
+      template <typename T>
+      void
+        operator()(
+          std::ostream& os,
+          T const& str)
+        const
+      {
+        os << " matching regular expression /" << str << "/";
+      }
+    };
+  }
+
+  template <
+    typename Kind = wildcard,
+    typename R = make_matcher_return<Kind, lambdas::regex_check, lambdas::regex_printer, std::string&&>>
+    auto
+    re(
+      std::string s,
+      std::regex_constants::syntax_option_type opt = std::regex_constants::ECMAScript,
+      std::regex_constants::match_flag_type match_type = std::regex_constants::match_default)
+    TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+  {
+    return make_matcher<Kind>(lambdas::regex_check(std::regex(s, opt),
+      match_type),
+      lambdas::regex_printer(),
+      std::move(s));
+  }
+
+  template <
+    typename Kind = wildcard,
+    typename R = make_matcher_return<Kind, lambdas::regex_check, lambdas::regex_printer, std::string&&>>
+    auto
+    re(
+      std::string s,
+      std::regex_constants::match_flag_type match_type)
+    TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+  {
+    return make_matcher<Kind>(lambdas::regex_check(std::regex(s), match_type),
+      lambdas::regex_printer(),
+      std::move(s));
+  }
+
+  inline
+    std::string
+    param_name_prefix(
+      ...)
+  {
+    return "";
+  }
+
+  template <typename M>
+  std::string
+    param_name_prefix(
+      const ptr_deref<M>*)
+  {
+    return "*" + ::trompeloeil::param_name_prefix(static_cast<M*>(nullptr));
+  }
+
+  template <typename M>
+  std::string
+    param_name_prefix(
+      const neg_matcher<M>*)
+  {
+    return "not " + ::trompeloeil::param_name_prefix(static_cast<M*>(nullptr));
+  }
+
+  template <typename T>
+  struct null_on_move
+  {
+  public:
+    null_on_move()
+      noexcept
+      : p{ nullptr }
+    {}
+
+    null_on_move(
+      T* p_)
+      noexcept
+      : p{ p_ }
+    {}
+
+    null_on_move(
+      null_on_move&&)
+      noexcept
+      : p{ nullptr }
+    {}
+
+    null_on_move(
+      null_on_move const&)
+      noexcept
+      : p{ nullptr }
+    {}
+
+    null_on_move&
+      operator=(
+        const null_on_move&)
+      noexcept
+    {
+      p = nullptr;
+      return *this;
+    }
+
+    null_on_move&
+      operator=(
+        null_on_move&&)
+      noexcept
+    {
+      p = nullptr;
+      return *this;
+    }
+
+    null_on_move&
+      operator=(
+        T* t)
+      noexcept
+    {
+      p = t;
+      return *this;
+    }
+
+    T*&
+      leak()
+      noexcept
+    {
+      return p;
+    }
+
+    T&
+      operator*()
+      const
+      noexcept
+    {
+      return *p;
+    }
+
+    T*
+      operator->()
+      const
+      noexcept
+    {
+      return p;
+    }
+
+    explicit
+      operator bool()
+      const
+      noexcept
+    {
+      return p != nullptr;
+    }
+  private:
+    T* p;
+  };
+
+  struct sequence_handler_base
+  {
+    virtual
+      ~sequence_handler_base()
+      noexcept = default;
+
+    virtual
+      void
+      validate(severity s, char const *, location) = 0;
+
+    virtual
+      bool
+      is_first()
+      const
+      noexcept = 0;
+
+    virtual
+      void
+      retire()
+      noexcept = 0;
+  };
+
+  template <size_t N>
+  struct sequence_handler : public sequence_handler_base
+  {
+  public:
+    template <typename ... S>
+    sequence_handler(
+      char const *name,
+      location loc,
+      S&& ... s)
+      noexcept
+      : matchers{ {name, loc, std::forward<S>(s)}... }
+    {
+    }
+
+    void
+      validate(
+        severity s,
+        char const *match_name,
+        location loc)
+      override
+    {
+      for (auto& e : matchers)
+      {
+        e.validate_match(s, match_name, loc);
+      }
+    }
+
+    bool
+      is_first()
+      const
+      noexcept
+      override
+    {
+      // std::all_of() is almost always preferable. The only reason
+      // for using a hand rolled loop is because it cuts compilation
+      // times quite noticeably (almost 10% with g++5.1)
+      for (auto& m : matchers)
+      {
+        if (!m.is_first()) return false;
+      }
+      return true;
+    }
+
+    void
+      retire()
+      noexcept
+      override
+    {
+      for (auto& e : matchers)
+      {
+        e.retire();
+      }
+    }
+  private:
+    sequence_matcher matchers[N];
+  };
+
+  struct lifetime_monitor;
+
+  template <typename T>
+  class deathwatched : public T
+  {
+    static_assert(std::has_virtual_destructor<T>::value,
+      "virtual destructor is a necessity for deathwatched to work");
+  public:
+    template <typename ... U,
+      typename = detail::enable_if_t<std::is_constructible<T, U...>::value>>
+      deathwatched(
+        U&& ...u)
+      noexcept(noexcept(T(std::declval<U>()...)))
+      : T(std::forward<U>(u)...)
+    {}
+
+    ~deathwatched();
+
+    trompeloeil::lifetime_monitor*&
+      trompeloeil_expect_death(
+        trompeloeil::lifetime_monitor* monitor)
+      const
+      noexcept
+    {
+      auto lock = get_lock();
+      trompeloeil_lifetime_monitor = monitor;
+      return trompeloeil_lifetime_monitor.leak();
+    }
+  private:
+    mutable null_on_move<trompeloeil::lifetime_monitor> trompeloeil_lifetime_monitor;
+  };
+
+  struct expectation {
+    virtual ~expectation() = default;
+    virtual bool is_satisfied() const noexcept = 0;
+    virtual bool is_saturated() const noexcept = 0;
+  };
+
+  struct lifetime_monitor : public expectation
+  {
+    template <typename T>
+    lifetime_monitor(
+      ::trompeloeil::deathwatched<T> const &obj,
+      char const* obj_name_,
+      char const* invocation_name_,
+      char const* call_name_,
+      location loc_)
+      noexcept
+      : object_monitor(obj.trompeloeil_expect_death(this))
+      , loc(loc_)
+      , object_name(obj_name_)
+      , invocation_name(invocation_name_)
+      , call_name(call_name_)
+    {
+    }
+
+    bool is_satisfied() const noexcept override
+    {
+      return died;
+    }
+
+    bool is_saturated() const noexcept override
+    {
+      return died;
+    }
+
+    lifetime_monitor(lifetime_monitor const&) = delete;
+
+    ~lifetime_monitor() override
+    {
+      auto lock = get_lock();
+      if (!died)
+      {
+        std::ostringstream os;
+        os << "Object " << object_name << " is still alive";
+        send_report<specialized>(severity::nonfatal, loc, os.str());
+        object_monitor = nullptr; // prevent its death poking this cadaver
+      }
+    }
+
+    void
+      notify()
+      noexcept
+    {
+      died = true;
+      if (sequences) sequences->validate(severity::nonfatal, call_name, loc);
+    }
+
+    template <typename ... T>
+    void
+      set_sequence(
+        T&& ... t)
+    {
+      auto seq = new sequence_handler<sizeof...(T)>(invocation_name,
+        loc,
+        std::forward<T>(t)...);
+      sequences.reset(seq);
+    }
+  private:
+    std::atomic<bool>  died{ false };
+    lifetime_monitor *&object_monitor;
+    location           loc;
+    char const        *object_name;
+    char const        *invocation_name;
+    char const        *call_name;
+    std::unique_ptr<sequence_handler_base>  sequences;
+  };
+
+  template <typename T>
+  deathwatched<T>::~deathwatched()
+  {
+    auto lock = get_lock();
+    if (trompeloeil_lifetime_monitor)
+    {
+      trompeloeil_lifetime_monitor->notify();
+      return;
+    }
+    std::ostringstream os;
+    os << "Unexpected destruction of "
+      << TROMPELOEIL_TYPE_ID_NAME(T) << "@" << this << '\n';
+    send_report<specialized>(severity::nonfatal,
+      location{},
+      os.str());
+  }
+
+  template <typename T>
+  struct return_of;
+
+  template <typename R, typename ... A>
+  struct return_of<R(A...)>
+  {
+    using type = R;
+  };
+
+  template <typename T>
+  using return_of_t = typename return_of<T>::type;
+
+  template <typename T>
+  struct call_params_type;
+
+  template <typename R, typename ... T>
+  struct call_params_type<R(T...)>
+  {
+    using type = std::tuple<typename std::add_lvalue_reference<T>::type...>;
+  };
+
+  template <typename T>
+  using call_params_type_t = typename call_params_type<T>::type;
+
+
+  template <typename R>
+  struct default_return_t
+  {
+    TROMPELOEIL_NORETURN static R value()
+    {
+      std::abort(); // must never be called
+    }
+  };
+
+  template <typename R>
+  inline
+    R
+    default_return()
+  {
+    /* Work around VS 2017 15.7.x C4702 warning by
+     * enclosing the operation in an otherwise
+     * unnecessary try/catch block.
+     */
+    try
+    {
+      return default_return_t<R>::value();
+    }
+    catch (...)
+    {
+      throw;
+    }
+  }
+
+
+
+  template <>
+  inline
+    void
+    default_return<void>()
+  {
+  }
+
+  template <typename Sig>
+  struct call_matcher_base;
+
+  template <typename Sig>
+  struct call_matcher_list : public list<call_matcher_base<Sig>>
+  {
+    void decommission()
+    {
+      auto lock = get_lock();
+      auto iter = this->begin();
+      auto const e = this->end();
+      while (iter != e)
+      {
+        auto i = iter++;
+        auto &m = *i;
+        m.mock_destroyed();
+        m.unlink();
+      }
+    }
+  };
+
+  template <typename Sig>
+  struct call_matcher_base : public list_elem<call_matcher_base<Sig>>
+  {
+    call_matcher_base(
+      location loc_,
+      char const* name_)
+      : loc{ loc_ }
+      , name{ name_ }
+    {
+    }
+
+    call_matcher_base(call_matcher_base&&) = delete;
+
+    virtual
+      ~call_matcher_base() = default;
+
+    virtual
+      void
+      mock_destroyed() = 0;
+
+    virtual
+      bool
+      matches(
+        call_params_type_t<Sig> const&)
+      const = 0;
+
+    virtual
+      bool
+      first_in_sequence()
+      const
+      noexcept = 0;
+
+    virtual
+      void
+      run_actions(
+        call_params_type_t<Sig> &,
+        call_matcher_list<Sig> &saturated_list
+      ) = 0;
+
+    virtual
+      std::ostream&
+      report_signature(
+        std::ostream&)
+      const = 0;
+
+    TROMPELOEIL_NORETURN
+      virtual
+      std::ostream&
+      report_mismatch(
+        std::ostream&,
+        call_params_type_t<Sig> const &) = 0;
+
+    virtual
+      return_of_t<Sig>
+      return_value(
+        trace_agent&,
+        call_params_type_t<Sig>& p) = 0;
+
+    location loc;
+    char const *name;
+  };
+
+  template <typename T, typename U>
+  bool
+    param_matches_impl(
+      T const& t,
+      U const& u,
+      matcher const*)
+    noexcept(noexcept(t.matches(u)))
+  {
+    return t.matches(u);
+  }
+
+  template <typename T,
+    typename U,
+    typename = detail::enable_if_t<is_equal_comparable<T, U>::value>>
+    inline
+    U&
+    identity(
+      U& t)
+    noexcept
+  {
+    return t;
+  }
+
+  template <typename T,
+    typename U,
+    typename = detail::enable_if_t<!is_equal_comparable<T, U>::value>>
+    inline
+    T
+    identity(
+      const U& u)
+    noexcept(noexcept(T(u)))
+  {
+    return u;
+  }
+
+  template <typename T, typename U>
+  bool
+    param_matches_impl(
+      T const& t,
+      U const& u,
+      ...)
+    noexcept(noexcept(::trompeloeil::identity<U>(t) == u))
+  {
+    return ::trompeloeil::identity<U>(t) == u;
+  }
+
+  template <typename T, typename U>
+  bool
+    param_matches(
+      T const& t,
+      U const& u)
+    noexcept(noexcept(param_matches_impl(t, u, &t)))
+  {
+    return ::trompeloeil::param_matches_impl(t, u, &t);
+  }
+
+  template <size_t ... I, typename T, typename U>
+  bool
+    match_parameters(
+      detail::index_sequence<I...>,
+      T const& t,
+      U const& u)
+    noexcept(noexcept(std::initializer_list<bool>{trompeloeil::param_matches(std::get<I>(t), std::get<I>(u))...}))
+  {
+    bool all_true = true;
+    ::trompeloeil::ignore(t, u); // Kills unmotivated VS2015 warning in the empty case
+    ::trompeloeil::ignore(std::initializer_list<bool>{all_true = all_true && ::trompeloeil::param_matches(std::get<I>(t), std::get<I>(u))...});
+    return all_true;
+  }
+
+  template <typename ... T, typename ... U>
+  bool
+    match_parameters(
+      std::tuple<T...> const& t,
+      std::tuple<U...> const& u)
+    noexcept(noexcept(match_parameters(detail::make_index_sequence<sizeof...(T)>{}, t, u)))
+  {
+    return ::trompeloeil::match_parameters(detail::make_index_sequence<sizeof...(T)>{}, t, u);
+  }
+
+  template <typename V, typename P>
+  void print_mismatch(
+    std::ostream& os,
+    size_t num,
+    V const& v,
+    P const& p)
+  {
+    if (!::trompeloeil::param_matches(v, p))
+    {
+      auto prefix = ::trompeloeil::param_name_prefix(&v) + "_";
+      os << "  Expected " << std::setw((num < 9) + 1) << prefix << num + 1;
+      ::trompeloeil::print_expectation(os, v);
+    }
+  }
+
+  template <typename ... V, typename ... P, size_t ... I>
+  void print_mismatch(
+    std::ostream& os,
+    detail::index_sequence<I...>,
+    std::tuple<V...> const& v,
+    std::tuple<P...> const& p)
+  {
+    ::trompeloeil::ignore(os, v, p);  // Kills unmotivated VS2015 warning in the empty case
+    ::trompeloeil::ignore(std::initializer_list<int>{(print_mismatch(os, I, std::get<I>(v), std::get<I>(p)), 0)...});
+  }
+
+  template <typename ... V, typename ... P>
+  void print_mismatch(
+    std::ostream& os,
+    std::tuple<V...> const& v,
+    std::tuple<P...> const& p)
+  {
+    print_mismatch(os, detail::make_index_sequence<sizeof...(V)>{}, v, p);
+  }
+
+  template <typename T>
+  void missed_value(
+    std::ostream& os,
+    int i,
+    T const& t)
+  {
+    auto prefix = ::trompeloeil::param_name_prefix(&t) + "_";
+    os << "  param " << std::setw((i < 9) + 1) << prefix << i + 1
+      << ::trompeloeil::param_compare_operator(&t);
+    ::trompeloeil::print(os, t);
+    os << '\n';
+  }
+
+  template <size_t ... I, typename ... T>
+  void stream_params(
+    std::ostream &os,
+    detail::index_sequence<I...>,
+    std::tuple<T...> const &t)
+  {
+    ::trompeloeil::ignore(os, t);  // Kills unmotivated VS2015 warning in the empty case
+    ::trompeloeil::ignore(std::initializer_list<int>{(missed_value(os, I, std::get<I>(t)), 0)...});
+  }
+
+  template <typename ... T>
+  void
+    stream_params(
+      std::ostream &os,
+      std::tuple<T...> const &t)
+  {
+    stream_params(os, detail::make_index_sequence<sizeof...(T)>{}, t);
+  }
+
+  template <typename ... T>
+  std::string
+    params_string(
+      std::tuple<T...> const& t)
+  {
+    std::ostringstream os;
+    stream_params(os, t);
+    return os.str();
+  }
+
+  class trace_agent
+  {
+  public:
+    trace_agent(
+      location loc_,
+      char const* name_,
+      tracer* t_)
+      : loc{ loc_ }
+      , t{ t_ }
+    {
+      if (t)
+      {
+        os << name_ << " with.\n";
+      }
+    }
+
+    trace_agent(trace_agent const&) = delete;
+
+    trace_agent(trace_agent &&) = delete;
+
+    ~trace_agent()
+    {
+      if (t)
+      {
+        t->trace(loc.file, loc.line, os.str());
+      }
+    }
+
+    trace_agent&
+      operator=(trace_agent const&) = delete;
+
+    trace_agent&
+      operator=(trace_agent &&) = delete;
+
+    template <typename ... T>
+    void
+      trace_params(
+        std::tuple<T...> const& params)
+    {
+      if (t)
+      {
+        stream_params(os, params);
+      }
+    }
+
+    template <typename T>
+    auto
+      trace_return(
+        T&& rv)
+      -> T
+    {
+      if (t)
+      {
+        os << " -> ";
+        print(os, rv);
+        os << '\n';
+      }
+      return std::forward<T>(rv);
+    }
+
+    void
+      trace_exception()
+    {
+      if (t)
+      {
+        try {
+          throw;
+        }
+        catch (std::exception& e)
+        {
+          os << "threw exception: what() = " << e.what() << '\n';
+        }
+        catch (...)
+        {
+          os << "threw unknown exception\n";
+        }
+      }
+    }
+  private:
+    location loc;
+    tracer* t;
+    std::ostringstream os;
+  };
+
+  template <typename Sig>
+  call_matcher_base <Sig> *
+    find(
+      call_matcher_list <Sig> &list,
+      call_params_type_t <Sig> const &p)
+    noexcept
+  {
+    call_matcher_base<Sig>* first_match = nullptr;
+    for (auto& i : list)
+    {
+      if (i.matches(p))
+      {
+        if (i.first_in_sequence())
+        {
+          return &i;
+        }
+        if (!first_match)
+        {
+          first_match = &i;
+        }
+      }
+    }
+    return first_match;
+  }
+
+  template <typename Sig>
+  TROMPELOEIL_NORETURN
+    void
+    report_mismatch(
+      call_matcher_list <Sig> &matcher_list,
+      call_matcher_list <Sig> &saturated_list,
+      std::string const &name,
+      call_params_type_t <Sig> const &p)
+  {
+    std::ostringstream os;
+    os << "No match for call of " << name << " with.\n";
+    stream_params(os, p);
+    bool saturated_match = false;
+    for (auto& m : saturated_list)
+    {
+      if (m.matches(p))
+      {
+        if (!saturated_match)
+        {
+          os << "\nMatches saturated call requirement\n";
+          saturated_match = true;
+        }
+        os << "  ";
+        m.report_signature(os) << '\n';
+      }
+    }
+    if (!saturated_match)
+    {
+      for (auto& m : matcher_list)
+      {
+        os << "\nTried ";
+        m.report_mismatch(os, p);
+      }
+    }
+    send_report<specialized>(severity::fatal, location{}, os.str());
+    std::abort(); // must never get here.
+  }
+
+  template <typename Sig>
+  class return_handler
+  {
+  public:
+    virtual
+      ~return_handler() = default;
+
+    virtual
+      return_of_t<Sig>
+      call(
+        trace_agent&,
+        call_params_type_t<Sig>& params) = 0;
+  };
+
+
+  template <typename Ret, typename F, typename P, typename = detail::enable_if_t<std::is_void<Ret>::value>>
+  void
+    trace_return(
+      trace_agent&,
+      F& func,
+      P& params)
+  {
+    func(params);
+  }
+
+  template <typename Ret, typename F, typename P, typename = detail::enable_if_t<!std::is_void<Ret>::value>>
+  Ret
+    trace_return(
+      trace_agent& agent,
+      F& func,
+      P& params)
+  {
+    /* Work around VS 2017 15.7.x C4702 warning by
+     * enclosing the operation in an otherwise
+     * unnecessary try/catch block.
+     */
+    try
+    {
+      return agent.trace_return(func(params));
+    }
+    catch (...)
+    {
+      throw;
+    }
+  }
+
+  template <typename Sig, typename T>
+  class return_handler_t : public return_handler<Sig>
+  {
+  public:
+    template <typename U>
+    return_handler_t(
+      U&& u)
+      : func(std::forward<U>(u))
+    {}
+
+    return_of_t<Sig>
+      call(
+        trace_agent& agent,
+        call_params_type_t<Sig>& params)
+      override
+    {
+      return trace_return<return_of_t<Sig>>(agent, func, params);
+    }
+  private:
+    T func;
+  };
+
+  template <typename Sig>
+  class condition_base : public list_elem<condition_base<Sig>>
+  {
+  public:
+    condition_base(
+      char const *n)
+      noexcept
+      : id(n)
+    {}
+
+    virtual
+      ~condition_base() = default;
+
+    virtual
+      bool
+      check(
+        call_params_type_t<Sig> const&)
+      const = 0;
+
+    virtual
+      char const*
+      name()
+      const
+      noexcept
+    {
+      return id;
+    }
+  private:
+    char const *id;
+  };
+
+  template <typename Sig>
+  using condition_list = list<condition_base<Sig>, delete_disposer>;
+
+  template <typename Sig, typename Cond>
+  struct condition : public condition_base<Sig>
+  {
+    condition(
+      char const *str_,
+      Cond c_)
+      : condition_base<Sig>(str_)
+      , c(c_) {}
+
+    bool
+      check(
+        call_params_type_t<Sig> const & t)
+      const
+      override
+    {
+      return c(t);
+    }
+
+  private:
+    Cond c;
+  };
+
+  template <typename Sig>
+  struct side_effect_base : public list_elem<side_effect_base<Sig>>
+  {
+    virtual
+      ~side_effect_base() = default;
+
+    virtual
+      void
+      action(
+        call_params_type_t<Sig> &)
+      const = 0;
+  };
+
+  template <typename Sig>
+  using side_effect_list = list<side_effect_base<Sig>, delete_disposer>;
+
+  template <typename Sig, typename Action>
+  struct side_effect : public side_effect_base<Sig>
+  {
+    template <typename A>
+    side_effect(
+      A&& a_)
+      : a(std::forward<A>(a_))
+    {}
+
+    void
+      action(
+        call_params_type_t<Sig> &t)
+      const
+      override
+    {
+      a(t);
+    }
+  private:
+    Action a;
+  };
+
+  template <unsigned long long L, unsigned long long H = L>
+  struct multiplicity { };
+
+  template <typename R, typename Parent>
+  struct return_injector : Parent
+  {
+    using return_type = R;
+  };
+
+  template <typename Parent>
+  struct throw_injector : Parent
+  {
+    static bool const throws = true;
+  };
+
+  template <typename Parent>
+  struct sideeffect_injector : Parent
+  {
+    static bool const side_effects = true;
+  };
+
+  template <typename Parent, unsigned long long H>
+  struct call_limit_injector : Parent
+  {
+    static bool               const call_limit_set = true;
+    static unsigned long long const upper_call_limit = H;
+  };
+
+  template <typename Parent>
+  struct call_limit_injector<Parent, 0ULL> : Parent
+  {
+    static bool const call_limit_set = true;
+    static unsigned long long const upper_call_limit = 0ULL;
+  };
+
+  template <typename Parent>
+  struct sequence_injector : Parent
+  {
+    static bool const sequence_set = true;
+  };
+
+  template <typename Matcher, typename modifier_tag, typename Parent>
+  struct call_modifier : public Parent
+  {
+    using typename Parent::signature;
+    using typename Parent::return_type;
+    using Parent::call_limit_set;
+    using Parent::upper_call_limit;
+    using Parent::sequence_set;
+    using Parent::throws;
+    using Parent::side_effects;
+
+    call_modifier(
+      Matcher* m)
+      noexcept
+      : matcher{ m }
+    {}
+
+    template <typename D>
+    call_modifier&&
+      with(
+        char const* str,
+        D&& d)
+      &&
+    {
+      matcher->add_condition(str, std::forward<D>(d));
+      return std::move(*this);
+    }
+
+    template <typename A>
+    call_modifier<Matcher, modifier_tag, sideeffect_injector<Parent>>
+      sideeffect(
+        A&& a)
+    {
+      constexpr bool forbidden = upper_call_limit == 0U;
+      static_assert(!forbidden,
+        "SIDE_EFFECT for forbidden call does not make sense");
+      matcher->add_side_effect(std::forward<A>(a));
+      return { std::move(matcher) };
+    }
+
+    template <typename H>
+    call_modifier<Matcher, modifier_tag, return_injector<return_of_t<signature>, Parent >>
+      handle_return(
+        H&& h)
+    {
+      using params_type = call_params_type_t<signature>&;
+      using sigret = return_of_t<signature>;
+      using ret = decltype(std::declval<H>()(std::declval<params_type>()));
+      // don't know why MS VS 2015 RC doesn't like std::result_of
+
+      constexpr bool is_illegal_type = std::is_same<detail::decay_t<ret>, illegal_argument>::value;
+      constexpr bool is_first_return = std::is_same<return_type, void>::value;
+      constexpr bool void_signature = std::is_same<sigret, void>::value;
+      constexpr bool is_pointer_sigret = std::is_pointer<sigret>::value;
+      constexpr bool is_pointer_ret = std::is_pointer<detail::decay_t<ret>>::value;
+      constexpr bool ptr_const_mismatch =
+        is_pointer_ret &&
+        is_pointer_sigret &&
+        !std::is_const<detail::remove_pointer_t<sigret>>{} &&
+        std::is_const<detail::remove_pointer_t<detail::decay_t<ret>>>{};
+      constexpr bool is_ref_sigret = std::is_reference<sigret>::value;
+      constexpr bool is_ref_ret = std::is_reference<ret>::value;
+      constexpr bool ref_const_mismatch =
+        is_ref_ret &&
+        is_ref_sigret &&
+        !std::is_const<detail::remove_reference_t<sigret>>::value &&
+        std::is_const<detail::remove_reference_t<ret>>::value;
+      constexpr bool matching_ret_type = std::is_constructible<sigret, ret>::value;
+      constexpr bool ref_value_mismatch = !is_ref_ret && is_ref_sigret;
+
+      static_assert(matching_ret_type || !void_signature,
+        "RETURN does not make sense for void-function");
+      static_assert(!is_illegal_type,
+        "RETURN illegal argument");
+      static_assert(!ptr_const_mismatch,
+        "RETURN const* from function returning pointer to non-const");
+      static_assert(!ref_value_mismatch || matching_ret_type,
+        "RETURN non-reference from function returning reference");
+      static_assert(ref_value_mismatch || !ref_const_mismatch,
+        "RETURN const& from function returning non-const reference");
+
+      static_assert(ptr_const_mismatch || ref_const_mismatch || is_illegal_type || matching_ret_type || void_signature,
+        "RETURN value is not convertible to the return type of the function");
+      static_assert(is_first_return,
+        "Multiple RETURN does not make sense");
+      static_assert(!throws || upper_call_limit == 0,
+        "THROW and RETURN does not make sense");
+      static_assert(upper_call_limit > 0ULL,
+        "RETURN for forbidden call does not make sense");
+
+      constexpr bool valid = !is_illegal_type && matching_ret_type && is_first_return && !throws && upper_call_limit > 0ULL;
+      using tag = std::integral_constant<bool, valid>;
+      matcher->set_return(tag{}, std::forward<H>(h));
+      return { matcher };
+    }
+
+    call_modifier&&
+      null_modifier()
+    {
+      return std::move(*this);
+    }
+
+  private:
+    template <typename H>
+    struct throw_handler_t
+    {
+      using R = decltype(default_return<return_of_t<signature>>());
+
+      throw_handler_t(H&& h_)
+        : h(std::forward<H>(h_))
+      {}
+
+      template <typename T>
+      R operator()(T& p)
+      {
+        /* Work around VS 2017 15.7.x C4702 warning by
+         * enclosing the operation in an otherwise
+         * unnecessary try/catch block.
+         */
+        try
+        {
+          h(p);
+        }
+        catch (...)
+        {
+          throw;
+        }
+        return R();
+      }
+
+    private:
+      H h;
+    };
+
+  public:
+    template <typename H>
+    call_modifier<Matcher, modifier_tag, throw_injector<Parent>>
+      handle_throw(
+        H&& h)
+    {
+      static_assert(!throws,
+        "Multiple THROW does not make sense");
+      constexpr bool has_return = !std::is_same<return_type, void>::value;
+      static_assert(!has_return,
+        "THROW and RETURN does not make sense");
+
+      constexpr bool forbidden = upper_call_limit == 0U;
+
+      static_assert(!forbidden,
+        "THROW for forbidden call does not make sense");
+
+      constexpr bool valid = !throws && !has_return;// && !forbidden;
+      using tag = std::integral_constant<bool, valid>;
+      auto handler = throw_handler_t<H>(std::forward<H>(h));
+      matcher->set_return(tag{}, std::move(handler));
+      return { matcher };
+    }
+
+    template <unsigned long long L,
+      unsigned long long H,
+      bool               times_set = call_limit_set>
+      call_modifier<Matcher, modifier_tag, call_limit_injector<Parent, H>>
+      times(
+        multiplicity<L, H>)
+    {
+      static_assert(!times_set,
+        "Only one TIMES call limit is allowed, but it can express an interval");
+
+      static_assert(H >= L,
+        "In TIMES the first value must not exceed the second");
+
+      static_assert(H > 0 || !throws,
+        "THROW and TIMES(0) does not make sense");
+
+      static_assert(H > 0 || std::is_same<return_type, void>::value,
+        "RETURN and TIMES(0) does not make sense");
+
+      static_assert(H > 0 || !side_effects,
+        "SIDE_EFFECT and TIMES(0) does not make sense");
+
+      static_assert(H > 0 || !sequence_set,
+        "IN_SEQUENCE and TIMES(0) does not make sense");
+
+      matcher->min_calls = L;
+      matcher->max_calls = H;
+      return { matcher };
+    }
+
+    template <typename ... T,
+      bool b = sequence_set>
+      call_modifier<Matcher, modifier_tag, sequence_injector<Parent>>
+      in_sequence(
+        T&& ... t)
+    {
+      static_assert(!b,
+        "Multiple IN_SEQUENCE does not make sense."
+        " You can list several sequence objects at once");
+
+      static_assert(upper_call_limit > 0ULL,
+        "IN_SEQUENCE for forbidden call does not make sense");
+
+      matcher->set_sequence(std::forward<T>(t)...);
+      return { matcher };
+    }
+    Matcher* matcher;
+  };
+
+  inline
+    void
+    report_unfulfilled(
+      const char* reason,
+      char const        *name,
+      std::string const &values,
+      unsigned long long min_calls,
+      unsigned long long call_count,
+      location           loc)
+  {
+    std::ostringstream os;
+    os << reason
+      << ":\nExpected " << name << " to be called ";
+    if (min_calls == 1)
+      os << "once";
+    else
+      os << min_calls << " times";
+    os << ", actually ";
+    switch (call_count)
+    {
+    case 0:
+      os << "never called\n"; break;
+    case 1:
+      os << "called once\n"; break;
+    default:
+      os << "called " << call_count << " times\n";
+    }
+    os << values;
+    send_report<specialized>(severity::nonfatal, loc, os.str());
+  }
+
+  inline
+    void
+    report_forbidden_call(
+      char const *name,
+      location loc,
+      std::string const& values)
+  {
+    std::ostringstream os;
+    os << "Match of forbidden call of " << name
+      << " at " << loc << '\n' << values;
+    send_report<specialized>(severity::fatal, loc, os.str());
+  }
+
+  template <typename Sig>
+  struct matcher_info
+  {
+    using signature = Sig;
+    using return_type = void;
+    static unsigned long long const upper_call_limit = 1;
+    static bool const throws = false;
+    static bool const call_limit_set = false;
+    static bool const sequence_set = false;
+    static bool const side_effects = false;
+  };
+
+
+  template <typename Sig, typename Value>
+  struct call_matcher : public call_matcher_base<Sig>, expectation
+  {
+    using call_matcher_base<Sig>::name;
+    using call_matcher_base<Sig>::loc;
+
+    template <typename ... U>
+    call_matcher(
+      char const *file,
+      unsigned long line,
+      char const *call_string,
+      U &&... u)
+      : call_matcher_base<Sig>(location{ file, line }, call_string)
+      , val(std::forward<U>(u)...)
+    {}
+
+    call_matcher(call_matcher &&r) = delete;
+
+    ~call_matcher() override
+    {
+      auto lock = get_lock();
+      if (is_unfulfilled())
+      {
+        report_missed("Unfulfilled expectation");
+      }
+      this->unlink();
+    }
+
+    bool
+      is_satisfied()
+      const
+      noexcept
+      override
+    {
+      auto lock = get_lock();
+      return call_count >= min_calls;
+    }
+
+    bool
+      is_saturated()
+      const
+      noexcept
+      override
+    {
+      auto lock = get_lock();
+      return call_count >= max_calls;
+    }
+    bool
+      is_unfulfilled()
+      const
+      noexcept
+    {
+      return !reported && this->is_linked() && call_count < min_calls;
+    }
+
+    void
+      mock_destroyed()
+      override
+    {
+      if (is_unfulfilled())
+      {
+        report_missed("Pending expectation on destroyed mock object");
+      }
+    }
+
+    call_matcher*
+      hook_last(
+        call_matcher_list<Sig> &list)
+      noexcept
+    {
+      list.push_front(this);
+      return this;
+    }
+
+    bool
+      matches(
+        call_params_type_t<Sig> const& params)
+      const
+      override
+    {
+      return match_parameters(val, params) && match_conditions(params);
+    }
+
+    bool
+      match_conditions(
+        call_params_type_t<Sig> const & params)
+      const
+    {
+      // std::all_of() is almost always preferable. The only reason
+      // for using a hand rolled loop is because it cuts compilation
+      // times quite noticeably (almost 10% with g++5.1)
+      for (auto& c : conditions)
+      {
+        if (!c.check(params)) return false;
+      }
+      return true;
+    }
+
+    bool
+      first_in_sequence()
+      const
+      noexcept
+      override
+    {
+      auto saturated = call_count >= min_calls;
+      return saturated || !sequences || sequences->is_first();
+    }
+
+    return_of_t<Sig>
+      return_value(
+        trace_agent& agent,
+        call_params_type_t<Sig>& params)
+      override
+    {
+      if (!return_handler_obj) return default_return<return_of_t<Sig>>();
+      return return_handler_obj->call(agent, params);
+    }
+
+    void
+      run_actions(
+        call_params_type_t<Sig>& params,
+        call_matcher_list<Sig> &saturated_list)
+      override
+    {
+      if (max_calls == 0)
+      {
+        reported = true;
+        report_forbidden_call(name, loc, params_string(params));
+      }
+      auto lock = get_lock();
+      {
+        if (call_count < min_calls && sequences)
+        {
+          sequences->validate(severity::fatal, name, loc);
+        }
+        if (++call_count == min_calls && sequences)
+        {
+          sequences->retire();
+        }
+        if (call_count == max_calls)
+        {
+          this->unlink();
+          saturated_list.push_back(this);
+        }
+      }
+      for (auto& a : actions) a.action(params);
+    }
+
+    std::ostream&
+      report_signature(
+        std::ostream& os)
+      const override
+    {
+      return os << name << " at " << loc;
+    }
+
+    std::ostream&
+      report_mismatch(
+        std::ostream& os,
+        call_params_type_t<Sig> const & params)
+      override
+    {
+      reported = true;
+      report_signature(os);
+      if (match_parameters(val, params))
+      {
+        for (auto& cond : conditions)
+        {
+          if (!cond.check(params))
+          {
+            os << "\n  Failed WITH(" << cond.name() << ')';
+          }
+        }
+      }
+      else
+      {
+        os << '\n';
+        ::trompeloeil::print_mismatch(os, val, params);
+      }
+      return os;
+    }
+
+    void
+      report_missed(
+        char const *reason)
+    {
+      reported = true;
+      report_unfulfilled(
+        reason,
+        name,
+        params_string(val),
+        min_calls,
+        call_count,
+        loc);
+    }
+
+    template <typename C>
+    void
+      add_condition(
+        char const *str,
+        C&& c)
+    {
+      auto cond = new condition<Sig, C>(str, std::forward<C>(c));
+      conditions.push_back(cond);
+    }
+
+    template <typename S>
+    void
+      add_side_effect(
+        S&& s)
+    {
+      auto effect = new side_effect<Sig, S>(std::forward<S>(s));
+      actions.push_back(effect);
+    }
+
+    template <typename ... T>
+    void
+      set_sequence(
+        T&& ... t)
+    {
+      auto seq = new sequence_handler<sizeof...(T)>(name,
+        loc,
+        std::forward<T>(t)...);
+      sequences.reset(seq);
+    }
+
+    template <typename T>
+    inline
+      void
+      set_return(
+        std::true_type,
+        T&& h)
+    {
+      using basic_t = typename std::remove_reference<T>::type;
+      using handler = return_handler_t<Sig, basic_t>;
+      return_handler_obj.reset(new handler(std::forward<T>(h)));
+    }
+
+    template <typename T>
+    inline                           // Never called. Used to limit errmsg
+      static                           // with RETURN of wrong type and after:
+      void                             //   FORBIDDEN_CALL
+      set_return(std::false_type, T&&t)//   RETURN
+      noexcept;                      //   THROW
+
+    condition_list<Sig>                    conditions;
+    side_effect_list<Sig>                  actions;
+    std::unique_ptr<return_handler<Sig>>   return_handler_obj;
+    std::unique_ptr<sequence_handler_base> sequences;
+    unsigned long long                     call_count = 0;
+    std::atomic<unsigned long long>        min_calls{ 1 };
+    std::atomic<unsigned long long>        max_calls{ 1 };
+    Value                                  val;
+    bool                                   reported = false;
+  };
+
+  /* Clang (all versions) does not like computing the return type R
+   * before determining if the function overload is the best match.
+   */
+  template <
+    int N,
+    typename T,
+    typename = detail::enable_if_t<N <= std::tuple_size<T>::value>,
+    typename R = decltype(std::get<N - 1>(std::declval<T>()))
+  >
+    constexpr
+    TROMPELOEIL_DECLTYPE_AUTO
+    arg(
+      T* t,
+      std::true_type)
+    TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+  {
+    return std::get<N - 1>(*t);
+  }
+
+  template <int N>
+  inline
+    constexpr
+    illegal_argument const
+    arg(
+      void const*,
+      std::false_type)
+    noexcept
+  {
+    return {};
+  }
+
+  template <
+    int N,
+    typename T,
+    typename R = decltype(arg<N>(std::declval<T*>(),
+      std::integral_constant<bool, (N <= std::tuple_size<T>::value)>{}))
+  >
+    TROMPELOEIL_DECLTYPE_AUTO
+    mkarg(
+      T& t)
+    noexcept
+    TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+  {
+    return arg<N>(&t, std::integral_constant<bool, (N <= std::tuple_size<T>::value)>{});
+  }
+
+  template <typename Mock>
+  struct call_validator_t
+  {
+    template <typename M, typename Tag, typename Info>
+    auto
+      make_expectation(
+        std::true_type,
+        call_modifier<M, Tag, Info>&& m)
+      const
+      noexcept
+      TROMPELOEIL_TRAILING_RETURN_TYPE(std::unique_ptr<expectation>)
+    {
+      auto lock = get_lock();
+      m.matcher->hook_last(obj.trompeloeil_matcher_list(static_cast<Tag*>(nullptr)));
+      return std::unique_ptr<expectation>(m.matcher);
+    }
+
+    template <typename T>
+    static                                           // Never called. Used to
+      std::unique_ptr<expectation>                     // limit errmsg when RETURN
+      make_expectation(std::false_type, T&&) noexcept; // is missing in non-void
+                                                       // function
+
+    template <typename M, typename Tag, typename Info>
+    inline
+      auto
+      operator+(
+        call_modifier<M, Tag, Info>&& t)
+      const
+      TROMPELOEIL_TRAILING_RETURN_TYPE(std::unique_ptr<expectation>)
+    {
+      using call = call_modifier<M, Tag, Info>;
+      using sigret = return_of_t<typename call::signature>;
+      using ret = typename call::return_type;
+      constexpr bool retmatch = std::is_same<ret, sigret>::value;
+      constexpr bool forbidden = call::upper_call_limit == 0ULL;
+      constexpr bool valid_return_type = call::throws || retmatch || forbidden;
+      static_assert(valid_return_type, "RETURN missing for non-void function");
+      auto tag = std::integral_constant<bool, valid_return_type>{};
+      return make_expectation(tag, std::move(t));
+    }
+    Mock& obj;
+  };
+
+  template <typename T,
+    typename = detail::enable_if_t<std::is_lvalue_reference<T&&>::value>>
+    inline
+    T&&
+    decay_return_type(
+      T&& t)
+  {
+    return std::forward<T>(t);
+  }
+
+  template <typename T,
+    typename = detail::enable_if_t<std::is_rvalue_reference<T&&>::value>>
+    inline
+    T
+    decay_return_type(
+      T&& t)
+  {
+    return std::forward<T>(t);
+  }
+
+  template <typename T, size_t N>
+  inline
+    T*
+    decay_return_type(
+      T(&t)[N])
+  {
+    return t;
+  }
+
+  template <bool sequence_set>
+  struct lifetime_monitor_modifier
+  {
+    operator std::unique_ptr<lifetime_monitor>() { return std::move(monitor); }
+    template <typename ... T, bool b = sequence_set>
+    lifetime_monitor_modifier<true>
+      in_sequence(T&& ... t)
+    {
+      static_assert(!b,
+        "Multiple IN_SEQUENCE does not make sense."
+        " You can list several sequence objects at once");
+      monitor->set_sequence(std::forward<T>(t)...);
+      return { std::move(monitor) };
+    }
+    std::unique_ptr<lifetime_monitor> monitor;
+  };
+
+  struct lifetime_monitor_releaser
+  {
+    template <bool b>
+    std::unique_ptr<trompeloeil::lifetime_monitor>
+      operator+(
+        lifetime_monitor_modifier<b>&& m)
+      const
+    {
+      return m;
+    }
+  };
+
+  template <bool movable, typename Sig>
+  struct expectations
+  {
+    expectations() = default;
+    expectations(expectations&&) = default;
+    ~expectations() {
+      active.decommission();
+      saturated.decommission();
+    }
+    call_matcher_list<Sig> active{};
+    call_matcher_list<Sig> saturated{};
+  };
+
+  template <typename Sig>
+  struct expectations<false, Sig>
+  {
+    expectations() = default;
+    expectations(expectations&&)
+    {
+      static_assert(std::is_same<Sig, void>::value,
+        "By default, mock objects are not movable. "
+        "To make a mock object movable, see: "
+        "https://github.com/rollbear/trompeloeil/blob/master/docs/reference.md#movable_mock");
+    }
+    ~expectations() {
+      active.decommission();
+      saturated.decommission();
+    }
+    call_matcher_list<Sig> active{};
+    call_matcher_list<Sig> saturated{};
+  };
+
+  template <typename Sig, typename ... P>
+  return_of_t<Sig> mock_func(std::false_type, P&& ...);
+
+
+  template <bool movable, typename Sig, typename ... P>
+  return_of_t<Sig>
+    mock_func(std::true_type,
+      expectations<movable, Sig>& e,
+      char const *func_name,
+      char const *sig_name,
+      P&& ... p)
+  {
+    auto lock = get_lock();
+
+    call_params_type_t<void(P...)> param_value(std::forward<P>(p)...);
+
+    auto i = find(e.active, param_value);
+    if (!i)
+    {
+      report_mismatch(e.active,
+        e.saturated,
+        func_name + std::string(" with signature ") + sig_name,
+        param_value);
+    }
+    trace_agent ta{ i->loc, i->name, tracer_obj() };
+    try
+    {
+      ta.trace_params(param_value);
+      i->run_actions(param_value, e.saturated);
+      return i->return_value(ta, param_value);
+    }
+    catch (...)
+    {
+      ta.trace_exception();
+      throw;
+    }
+  }
+
+  template <typename ... U>
+  struct param_helper {
+    using type = decltype(std::make_tuple(std::declval<U>()...));
+  };
+
+  template <typename ... U>
+  using param_t = typename param_helper<U...>::type;
+
+  template <typename sig, typename tag, typename... U>
+  using modifier_t = call_modifier<call_matcher<sig, param_t<U...>>,
+    tag,
+    matcher_info<sig>>;
+
+  template <typename M,
+    typename = detail::enable_if_t<::trompeloeil::is_matcher<M>::value>>
+    inline
+    ::trompeloeil::ptr_deref<detail::decay_t<M>>
+    operator*(
+      M&& m)
+  {
+    return ::trompeloeil::ptr_deref<detail::decay_t<M>>{std::forward<M>(m)};
+  }
+
+  template <typename M,
+    typename = detail::enable_if_t<::trompeloeil::is_matcher<M>::value>>
+    inline
+    ::trompeloeil::neg_matcher<detail::decay_t<M>>
+    operator!(
+      M&& m)
+  {
+    return ::trompeloeil::neg_matcher<detail::decay_t<M>>{std::forward<M>(m)};
+  }
+
+  /*
+   * Convert the signature S of a mock function to the signature of
+   * a member function of class T that takes the same parameters P
+   * but returns R.
+   *
+   * The member function has the same constness as the mock function.
+   */
+  template <typename T, typename R, typename S>
+  struct signature_to_member_function;
+
+  template <typename T, typename R, typename R_of_S, typename... P>
+  struct signature_to_member_function<T, R, R_of_S(P...)>
+  {
+    using type = detail::conditional_t<
+      std::is_const<T>::value,
+      R(T::*)(P...) const,
+      R(T::*)(P...)>;
+  };
+
+  template <typename T>
+  struct mock_interface : public T
+  {
+    using trompeloeil_interface_name = T;
+    using T::T;
+  };
+
+#if defined(TROMPELOEIL_USER_DEFINED_COMPILE_TIME_REPORTER)
+  extern template struct reporter<specialized>;
+#endif // TROMPELOEIL_USER_DEFINED_COMPILE_TIME_REPORTER
+}
+
+#define TROMPELOEIL_LINE_ID(name)                                        \
+  TROMPELOEIL_CONCAT(trompeloeil_l_ ## name ## _, __LINE__)
+
+#define TROMPELOEIL_COUNT_ID(name)                                       \
+  TROMPELOEIL_CONCAT(trompeloeil_c_ ## name ## _, __COUNTER__)
+
+#ifdef _MSC_VER
+#define TROMPELOEIL_MAKE_MOCK0(name, sig, ...)                           \
+  TROMPELOEIL_MAKE_MOCK_(name,,0, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK1(name, sig, ...)                           \
+  TROMPELOEIL_MAKE_MOCK_(name,,1, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK2(name, sig, ...)                           \
+  TROMPELOEIL_MAKE_MOCK_(name,,2, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK3(name, sig, ...)                           \
+  TROMPELOEIL_MAKE_MOCK_(name,,3, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK4(name, sig, ...)                           \
+  TROMPELOEIL_MAKE_MOCK_(name,,4, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK5(name, sig, ...)                           \
+  TROMPELOEIL_MAKE_MOCK_(name,,5, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK6(name, sig, ...)                           \
+  TROMPELOEIL_MAKE_MOCK_(name,,6, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK7(name, sig, ...)                           \
+  TROMPELOEIL_MAKE_MOCK_(name,,7, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK8(name, sig, ...)                           \
+  TROMPELOEIL_MAKE_MOCK_(name,,8, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK9(name, sig, ...)                           \
+  TROMPELOEIL_MAKE_MOCK_(name,,9, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK10(name, sig, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,,10, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK11(name, sig, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,,11, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK12(name, sig, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,,12, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK13(name, sig, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,,13, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK14(name, sig, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,,14, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK15(name, sig, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,,15, sig, __VA_ARGS__,,)
+
+#define TROMPELOEIL_MAKE_CONST_MOCK0(name, sig, ...)                     \
+  TROMPELOEIL_MAKE_MOCK_(name,const,0, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK1(name, sig, ...)                     \
+  TROMPELOEIL_MAKE_MOCK_(name,const,1, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK2(name, sig, ...)                     \
+  TROMPELOEIL_MAKE_MOCK_(name,const,2, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK3(name, sig, ...)                     \
+  TROMPELOEIL_MAKE_MOCK_(name,const,3, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK4(name, sig, ...)                     \
+  TROMPELOEIL_MAKE_MOCK_(name,const,4, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK5(name, sig, ...)                     \
+  TROMPELOEIL_MAKE_MOCK_(name,const,5, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK6(name, sig, ...)                     \
+  TROMPELOEIL_MAKE_MOCK_(name,const,6, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK7(name, sig, ...)                     \
+  TROMPELOEIL_MAKE_MOCK_(name,const,7, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK8(name, sig, ...)                     \
+  TROMPELOEIL_MAKE_MOCK_(name,const,8, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK9(name, sig, ...)                     \
+  TROMPELOEIL_MAKE_MOCK_(name,const,9, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK10(name, sig, ...)                    \
+  TROMPELOEIL_MAKE_MOCK_(name,const,10, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK11(name, sig, ...)                    \
+  TROMPELOEIL_MAKE_MOCK_(name,const,11, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK12(name, sig, ...)                    \
+  TROMPELOEIL_MAKE_MOCK_(name,const,12, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK13(name, sig, ...)                    \
+  TROMPELOEIL_MAKE_MOCK_(name,const,13, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK14(name, sig, ...)                    \
+  TROMPELOEIL_MAKE_MOCK_(name,const,14, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK15(name, sig, ...)                    \
+  TROMPELOEIL_MAKE_MOCK_(name,const,15, sig, __VA_ARGS__,,)
+
+
+#else
+// sane standards compliant preprocessor
+
+#define TROMPELOEIL_MAKE_MOCK0(name, ...)                                \
+  TROMPELOEIL_MAKE_MOCK_(name,,0, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK1(name, ...)                                \
+  TROMPELOEIL_MAKE_MOCK_(name,,1, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK2(name, ...)                                \
+  TROMPELOEIL_MAKE_MOCK_(name,,2, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK3(name, ...)                                \
+  TROMPELOEIL_MAKE_MOCK_(name,,3, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK4(name, ...)                                \
+  TROMPELOEIL_MAKE_MOCK_(name,,4, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK5(name, ...)                                \
+  TROMPELOEIL_MAKE_MOCK_(name,,5, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK6(name, ...)                                \
+  TROMPELOEIL_MAKE_MOCK_(name,,6, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK7(name, ...)                                \
+  TROMPELOEIL_MAKE_MOCK_(name,,7, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK8(name, ...)                                \
+  TROMPELOEIL_MAKE_MOCK_(name,,8, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK9(name, ...)                                \
+  TROMPELOEIL_MAKE_MOCK_(name,,9, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK10(name, ...)                               \
+  TROMPELOEIL_MAKE_MOCK_(name,,10, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK11(name, ...)                               \
+  TROMPELOEIL_MAKE_MOCK_(name,,11, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK12(name, ...)                               \
+  TROMPELOEIL_MAKE_MOCK_(name,,12, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK13(name, ...)                               \
+  TROMPELOEIL_MAKE_MOCK_(name,,13, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK14(name, ...)                               \
+  TROMPELOEIL_MAKE_MOCK_(name,,14,__VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK15(name, ...)                               \
+  TROMPELOEIL_MAKE_MOCK_(name,,15, __VA_ARGS__,,)
+
+#define TROMPELOEIL_MAKE_CONST_MOCK0(name, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,const,0, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK1(name, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,const,1, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK2(name, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,const,2, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK3(name, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,const,3, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK4(name, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,const,4, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK5(name, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,const,5, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK6(name, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,const,6, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK7(name, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,const,7, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK8(name, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,const,8, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK9(name, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,const,9, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK10(name, ...)                         \
+  TROMPELOEIL_MAKE_MOCK_(name,const,10, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK11(name, ...)                         \
+  TROMPELOEIL_MAKE_MOCK_(name,const,11, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK12(name, ...)                         \
+  TROMPELOEIL_MAKE_MOCK_(name,const,12, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK13(name, ...)                         \
+  TROMPELOEIL_MAKE_MOCK_(name,const,13, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK14(name, ...)                         \
+  TROMPELOEIL_MAKE_MOCK_(name,const,14, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK15(name, ...)                         \
+  TROMPELOEIL_MAKE_MOCK_(name,const,15, __VA_ARGS__,,)
+
+#endif
+
+#define TROMPELOEIL_IMPLEMENT_MOCK0(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(0, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK1(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(1, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK2(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(2, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK3(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(3, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK4(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(4, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK5(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(5, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK6(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(6, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK7(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(7, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK8(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(8, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK9(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(9, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK10(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(10, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK11(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(11, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK12(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(12, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK13(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(13, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK14(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(14, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK15(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(15, name)
+
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK0(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(0, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK1(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(1, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK2(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(2, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK3(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(3, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK4(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(4, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK5(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(5, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK6(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(6, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK7(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(7, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK8(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(8, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK9(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(9, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK10(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(10, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK11(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(11, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK12(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(12, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK13(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(13, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK14(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(14, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK15(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(15, name)
+
+#define TROMPELOEIL_IMPLEMENT_MOCK_(num, name) \
+  TROMPELOEIL_MAKE_MOCK_(name,,num, decltype(::trompeloeil::nonconst_member_signature(&trompeloeil_interface_name::name))::type,override,)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK_(num, name) \
+  TROMPELOEIL_MAKE_MOCK_(name,const,num, decltype(::trompeloeil::const_member_signature(&trompeloeil_interface_name::name))::type,override,)
+
+#define TROMPELOEIL_MAKE_MOCK_(name, constness, num, sig, spec, ...)           \
+  using TROMPELOEIL_LINE_ID(cardinality_match) =                               \
+    std::integral_constant<bool, num == ::trompeloeil::param_list<sig>::size>; \
+  static_assert(TROMPELOEIL_LINE_ID(cardinality_match)::value,                 \
+                "Function signature does not have " #num " parameters");       \
+  using TROMPELOEIL_LINE_ID(matcher_list_t) = ::trompeloeil::call_matcher_list<sig>;\
+  using TROMPELOEIL_LINE_ID(expectation_list_t) =                              \
+    ::trompeloeil::expectations<trompeloeil_movable_mock, sig>;                \
+                                                                               \
+  struct TROMPELOEIL_LINE_ID(tag_type_trompeloeil)                             \
+  {                                                                            \
+    const char* trompeloeil_expectation_file;                                  \
+    unsigned long trompeloeil_expectation_line;                                \
+    const char *trompeloeil_expectation_string;                                \
+                                                                               \
+    /* Work around parsing bug in VS 2015 when a "complex" */                  \
+    /* decltype() appears in a trailing return type. */                        \
+    /* Further, work around C2066 defect in VS 2017 15.7.1. */                 \
+    using trompeloeil_sig_t = typename ::trompeloeil::identity_type<sig>::type;\
+                                                                               \
+    using trompeloeil_call_params_type_t =                                     \
+      ::trompeloeil::call_params_type_t<sig>;                                  \
+                                                                               \
+    using trompeloeil_return_of_t = ::trompeloeil::return_of_t<sig>;           \
+                                                                               \
+    template <typename ... trompeloeil_param_type>                             \
+    auto name(                                                                 \
+      trompeloeil_param_type&& ... trompeloeil_param)                          \
+      -> ::trompeloeil::modifier_t<trompeloeil_sig_t,                          \
+                                   TROMPELOEIL_LINE_ID(tag_type_trompeloeil),  \
+                                   trompeloeil_param_type...>                  \
+    {                                                                          \
+      using matcher = ::trompeloeil::call_matcher<                             \
+                          sig,                                                 \
+                          ::trompeloeil::param_t<trompeloeil_param_type...>>;  \
+      return {                                                                 \
+          new matcher {                                                        \
+                trompeloeil_expectation_file,                                  \
+                trompeloeil_expectation_line,                                  \
+                trompeloeil_expectation_string,                                \
+                std::forward<trompeloeil_param_type>(trompeloeil_param)...     \
+              }                                                                \
+      };                                                                       \
+    }                                                                          \
+  };                                                                           \
+                                                                               \
+  TROMPELOEIL_LINE_ID(matcher_list_t)&                                         \
+  trompeloeil_matcher_list(                                                    \
+    TROMPELOEIL_LINE_ID(tag_type_trompeloeil)*)                                \
+  constness                                                                    \
+  noexcept                                                                     \
+  {                                                                            \
+    return TROMPELOEIL_LINE_ID(expectations).active;                           \
+  }                                                                            \
+                                                                               \
+  ::trompeloeil::return_of_t<sig>                                              \
+  name(                                                                        \
+    TROMPELOEIL_PARAM_LIST(num, sig))                                          \
+  constness                                                                    \
+  spec                                                                         \
+  {                                                                            \
+    /* Use the auxiliary functions to avoid unneeded-member-function warning */\
+    using T_ ## name = typename std::remove_reference<decltype(*this)>::type;  \
+                                                                               \
+    using pmf_s_t = typename ::trompeloeil::signature_to_member_function<      \
+      T_ ## name, decltype(*this), sig>::type const;                           \
+                                                                               \
+    using pmf_e_t = typename ::trompeloeil::signature_to_member_function<      \
+      T_ ## name, TROMPELOEIL_LINE_ID(tag_type_trompeloeil), sig>::type const; \
+                                                                               \
+    pmf_s_t const s_ptr = &T_ ## name::trompeloeil_self_ ## name;              \
+    pmf_e_t const e_ptr = &T_ ## name::trompeloeil_tag_ ## name;               \
+                                                                               \
+    ::trompeloeil::ignore(s_ptr, e_ptr);                                       \
+                                                                               \
+    return ::trompeloeil::mock_func<trompeloeil_movable_mock, sig>(            \
+                                    TROMPELOEIL_LINE_ID(cardinality_match){},  \
+                                    TROMPELOEIL_LINE_ID(expectations),         \
+                                    #name,                                     \
+                                    #sig                                       \
+                                    TROMPELOEIL_PARAMS(num));                  \
+  }                                                                            \
+                                                                               \
+  auto                                                                         \
+  trompeloeil_self_ ## name(TROMPELOEIL_PARAM_LIST(num, sig)) constness        \
+    -> decltype(*this)                                                         \
+  {                                                                            \
+    ::trompeloeil::ignore(#name TROMPELOEIL_PARAMS(num));                      \
+    return *this;                                                              \
+  }                                                                            \
+                                                                               \
+  TROMPELOEIL_LINE_ID(tag_type_trompeloeil)                                    \
+  trompeloeil_tag_ ## name(TROMPELOEIL_PARAM_LIST(num, sig)) constness         \
+  {                                                                            \
+    ::trompeloeil::ignore(#name TROMPELOEIL_PARAMS(num));                      \
+    return {nullptr, 0ul, nullptr};                                            \
+  }                                                                            \
+                                                                               \
+  mutable TROMPELOEIL_LINE_ID(expectation_list_t) TROMPELOEIL_LINE_ID(expectations){}
+
+
+#define TROMPELOEIL_LPAREN (
+
+#define TROMPELOEIL_MORE_THAN_TWO_ARGS(...)                                    \
+  TROMPELOEIL_IDENTITY(                                                        \
+    TROMPELOEIL_ARG16(__VA_ARGS__,                                             \
+                      T, T, T, T, T, T, T, T, T, T, T, T, T, F, F, F))
+
+
+#define TROMPELOEIL_REQUIRE_CALL_V(...)                                        \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_REQUIRE_CALL_IMPL TROMPELOEIL_LPAREN        \
+      TROMPELOEIL_MORE_THAN_TWO_ARGS(__VA_ARGS__), __VA_ARGS__))
+
+// Dispatch to _F (0, 1, or 2 arguments) or _T (> 2 arguments) macro
+#define TROMPELOEIL_REQUIRE_CALL_IMPL(N, ...)                                  \
+    TROMPELOEIL_IDENTITY(                                                      \
+      TROMPELOEIL_REQUIRE_CALL_ ## N TROMPELOEIL_LPAREN __VA_ARGS__))
+
+// Accept only two arguments
+#define TROMPELOEIL_REQUIRE_CALL_F(obj, func)                                  \
+  auto TROMPELOEIL_COUNT_ID(call_obj) =                                        \
+    TROMPELOEIL_REQUIRE_CALL_V_LAMBDA(obj, func, #obj, #func, .null_modifier())
+
+// Accept three or more arguments.
+#define TROMPELOEIL_REQUIRE_CALL_T(obj, func, ...)                             \
+  auto TROMPELOEIL_COUNT_ID(call_obj) =                                        \
+    TROMPELOEIL_REQUIRE_CALL_V_LAMBDA(obj, func, #obj, #func, __VA_ARGS__)
+
+
+#define TROMPELOEIL_REQUIRE_CALL_V_LAMBDA(obj, func, obj_s, func_s, ...)       \
+  [&]                                                                          \
+  {                                                                            \
+    using trompeloeil_s_t = decltype((obj)                                     \
+                              .TROMPELOEIL_CONCAT(trompeloeil_self_, func));   \
+    using trompeloeil_e_t = decltype((obj)                                     \
+                              .TROMPELOEIL_CONCAT(trompeloeil_tag_,func));     \
+                                                                               \
+    return TROMPELOEIL_REQUIRE_CALL_LAMBDA_OBJ(obj, func, obj_s, func_s)       \
+      __VA_ARGS__                                                              \
+      ;                                                                        \
+  }()
+
+
+#define TROMPELOEIL_REQUIRE_CALL_LAMBDA_OBJ(obj, func, obj_s, func_s)          \
+  ::trompeloeil::call_validator_t<trompeloeil_s_t>{(obj)} +                    \
+      ::trompeloeil::detail::conditional_t<false,                              \
+                                           decltype((obj).func),               \
+                                           trompeloeil_e_t>                    \
+    {__FILE__, static_cast<unsigned long>(__LINE__), obj_s "." func_s}.func
+
+
+#define TROMPELOEIL_NAMED_REQUIRE_CALL_V(...)                                  \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_NAMED_REQUIRE_CALL_IMPL TROMPELOEIL_LPAREN  \
+    TROMPELOEIL_MORE_THAN_TWO_ARGS(__VA_ARGS__), __VA_ARGS__))
+
+// Dispatch to _F (0, 1, or 2 arguments) or _T (> 2 arguments) macro
+#define TROMPELOEIL_NAMED_REQUIRE_CALL_IMPL(N, ...)                            \
+  TROMPELOEIL_IDENTITY(                                                        \
+    TROMPELOEIL_NAMED_REQUIRE_CALL_ ## N TROMPELOEIL_LPAREN __VA_ARGS__))
+
+// Accept only two arguments
+#define TROMPELOEIL_NAMED_REQUIRE_CALL_F(obj, func)                            \
+  TROMPELOEIL_REQUIRE_CALL_V_LAMBDA(obj, func, #obj, #func, .null_modifier())
+
+// Accept three or more arguments.
+#define TROMPELOEIL_NAMED_REQUIRE_CALL_T(obj, func, ...)                       \
+  TROMPELOEIL_REQUIRE_CALL_V_LAMBDA(obj, func, #obj, #func, __VA_ARGS__)
+
+
+#define TROMPELOEIL_ALLOW_CALL_V(...)                                          \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_ALLOW_CALL_IMPL TROMPELOEIL_LPAREN          \
+    TROMPELOEIL_MORE_THAN_TWO_ARGS(__VA_ARGS__), __VA_ARGS__))
+
+// Dispatch to _F (0, 1, or 2 arguments) or _T (> 2 arguments) macro
+#define TROMPELOEIL_ALLOW_CALL_IMPL(N, ...)                                    \
+  TROMPELOEIL_IDENTITY(                                                        \
+    TROMPELOEIL_ALLOW_CALL_ ## N TROMPELOEIL_LPAREN __VA_ARGS__))
+
+// Accept only two arguments
+#define TROMPELOEIL_ALLOW_CALL_F(obj, func)                                    \
+  TROMPELOEIL_REQUIRE_CALL_T(obj, func, .TROMPELOEIL_TIMES(0, ~0ULL))
+
+// Accept three or more arguments.
+#define TROMPELOEIL_ALLOW_CALL_T(obj, func, ...)                               \
+  TROMPELOEIL_REQUIRE_CALL_T(obj,                                              \
+                             func,                                             \
+                             .TROMPELOEIL_TIMES(0, ~0ULL) __VA_ARGS__)
+
+
+#define TROMPELOEIL_NAMED_ALLOW_CALL_V(...)                                    \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_NAMED_ALLOW_CALL_IMPL TROMPELOEIL_LPAREN    \
+    TROMPELOEIL_MORE_THAN_TWO_ARGS(__VA_ARGS__), __VA_ARGS__))
+
+// Dispatch to _F (0, 1, or 2 arguments) or _T (> 2 arguments) macro
+#define TROMPELOEIL_NAMED_ALLOW_CALL_IMPL(N, ...)                              \
+  TROMPELOEIL_IDENTITY(                                                        \
+    TROMPELOEIL_NAMED_ALLOW_CALL_ ## N TROMPELOEIL_LPAREN __VA_ARGS__))
+
+// Accept only two arguments
+#define TROMPELOEIL_NAMED_ALLOW_CALL_F(obj, func)                              \
+  TROMPELOEIL_NAMED_REQUIRE_CALL_T(obj, func, .TROMPELOEIL_TIMES(0, ~0ULL))
+
+// Accept three or more arguments.
+#define TROMPELOEIL_NAMED_ALLOW_CALL_T(obj, func, ...)                         \
+  TROMPELOEIL_NAMED_REQUIRE_CALL_T(obj,                                        \
+                                   func,                                       \
+                                   .TROMPELOEIL_TIMES(0, ~0ULL) __VA_ARGS__)
+
+
+#define TROMPELOEIL_FORBID_CALL_V(...)                                         \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_FORBID_CALL_IMPL TROMPELOEIL_LPAREN         \
+    TROMPELOEIL_MORE_THAN_TWO_ARGS(__VA_ARGS__), __VA_ARGS__))
+
+// Dispatch to _F (0, 1, or 2 arguments) or _T (> 2 arguments) macro
+#define TROMPELOEIL_FORBID_CALL_IMPL(N, ...)                                   \
+  TROMPELOEIL_IDENTITY(                                                        \
+    TROMPELOEIL_FORBID_CALL_ ## N TROMPELOEIL_LPAREN __VA_ARGS__))
+
+// Accept only two arguments
+#define TROMPELOEIL_FORBID_CALL_F(obj, func)                                   \
+  TROMPELOEIL_REQUIRE_CALL_T(obj, func, .TROMPELOEIL_TIMES(0))
+
+// Accept three or more arguments.
+#define TROMPELOEIL_FORBID_CALL_T(obj, func, ...)                              \
+  TROMPELOEIL_REQUIRE_CALL_T(obj,                                              \
+                             func,                                             \
+                             .TROMPELOEIL_TIMES(0) __VA_ARGS__)
+
+
+#define TROMPELOEIL_NAMED_FORBID_CALL_V(...)                                   \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_NAMED_FORBID_CALL_IMPL TROMPELOEIL_LPAREN   \
+    TROMPELOEIL_MORE_THAN_TWO_ARGS(__VA_ARGS__), __VA_ARGS__))
+
+// Dispatch to _F (0, 1, or 2 arguments) or _T (> 2 arguments) macro
+#define TROMPELOEIL_NAMED_FORBID_CALL_IMPL(N, ...)                             \
+  TROMPELOEIL_IDENTITY(                                                        \
+    TROMPELOEIL_NAMED_FORBID_CALL_ ## N TROMPELOEIL_LPAREN __VA_ARGS__))
+
+// Accept only two arguments
+#define TROMPELOEIL_NAMED_FORBID_CALL_F(obj, func)                             \
+  TROMPELOEIL_NAMED_REQUIRE_CALL_T(obj, func, .TROMPELOEIL_TIMES(0))
+
+// Accept three or more arguments.
+#define TROMPELOEIL_NAMED_FORBID_CALL_T(obj, func, ...)                        \
+  TROMPELOEIL_NAMED_REQUIRE_CALL_T(obj,                                        \
+                                   func,                                       \
+                                   .TROMPELOEIL_TIMES(0) __VA_ARGS__)
+
+
+#if (TROMPELOEIL_CPLUSPLUS > 201103L)
+
+#define TROMPELOEIL_REQUIRE_CALL(obj, func)                                    \
+  TROMPELOEIL_REQUIRE_CALL_(obj, func, #obj, #func)
+
+#define TROMPELOEIL_REQUIRE_CALL_(obj, func, obj_s, func_s)                    \
+  auto TROMPELOEIL_COUNT_ID(call_obj) = TROMPELOEIL_REQUIRE_CALL_OBJ(obj, func,\
+                                                               obj_s, func_s)
+
+#define TROMPELOEIL_NAMED_REQUIRE_CALL(obj, func)                              \
+  TROMPELOEIL_NAMED_REQUIRE_CALL_(obj, func, #obj, #func)
+
+#define TROMPELOEIL_NAMED_REQUIRE_CALL_(obj, func, obj_s, func_s)              \
+  TROMPELOEIL_REQUIRE_CALL_OBJ(obj, func, obj_s, func_s)
+
+
+#define TROMPELOEIL_REQUIRE_CALL_OBJ(obj, func, obj_s, func_s)                 \
+  ::trompeloeil::call_validator_t<decltype((obj).TROMPELOEIL_CONCAT(trompeloeil_self_, func))>{(obj)} + \
+    ::trompeloeil::detail::conditional_t<false,                                \
+                       decltype((obj).func),                                   \
+                       decltype((obj).TROMPELOEIL_CONCAT(trompeloeil_tag_,func))>\
+    {__FILE__, static_cast<unsigned long>(__LINE__), obj_s "." func_s}.func
+
+
+#define TROMPELOEIL_ALLOW_CALL(obj, func)                                      \
+  TROMPELOEIL_ALLOW_CALL_(obj, func, #obj, #func)
+
+#define TROMPELOEIL_ALLOW_CALL_(obj, func, obj_s, func_s)                      \
+  TROMPELOEIL_REQUIRE_CALL_(obj, func, obj_s, func_s)                          \
+    .TROMPELOEIL_TIMES(0, ~0ULL)
+
+
+#define TROMPELOEIL_NAMED_ALLOW_CALL(obj, func)                                \
+  TROMPELOEIL_NAMED_ALLOW_CALL_(obj, func, #obj, #func)
+
+#define TROMPELOEIL_NAMED_ALLOW_CALL_(obj, func, obj_s, func_s)                \
+  TROMPELOEIL_NAMED_REQUIRE_CALL_(obj, func, obj_s, func_s)                    \
+    .TROMPELOEIL_TIMES(0, ~0ULL)
+
+
+#define TROMPELOEIL_FORBID_CALL(obj, func)                                     \
+  TROMPELOEIL_FORBID_CALL_(obj, func, #obj, #func)
+
+#define TROMPELOEIL_FORBID_CALL_(obj, func, obj_s, func_s)                     \
+  TROMPELOEIL_REQUIRE_CALL_(obj, func, obj_s, func_s)                          \
+    .TROMPELOEIL_TIMES(0)
+
+
+#define TROMPELOEIL_NAMED_FORBID_CALL(obj, func)                               \
+  TROMPELOEIL_NAMED_FORBID_CALL_(obj, func, #obj, #func)
+
+#define TROMPELOEIL_NAMED_FORBID_CALL_(obj, func, obj_s, func_s)               \
+  TROMPELOEIL_NAMED_REQUIRE_CALL_(obj, func, obj_s, func_s)                    \
+    .TROMPELOEIL_TIMES(0)
+
+#endif /* (TROMPELOEIL_CPLUSPLUS > 201103L) */
+
+
+#define TROMPELOEIL_WITH(...)    TROMPELOEIL_WITH_(=,#__VA_ARGS__, __VA_ARGS__)
+#define TROMPELOEIL_LR_WITH(...) TROMPELOEIL_WITH_(&,#__VA_ARGS__, __VA_ARGS__)
+
+
+#if (TROMPELOEIL_CPLUSPLUS == 201103L)
+
+#define TROMPELOEIL_WITH_(capture, arg_s, ...)                                 \
+  with(                                                                        \
+    arg_s,                                                                     \
+    [capture]                                                                  \
+    (trompeloeil_e_t::trompeloeil_call_params_type_t const& trompeloeil_x)     \
+    {                                                                          \
+      auto& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                       \
+      auto& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                       \
+      auto& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                       \
+      auto& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                       \
+      auto& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                       \
+      auto& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                       \
+      auto& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                       \
+      auto& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                       \
+      auto& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                       \
+      auto&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                      \
+      auto&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                      \
+      auto&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                      \
+      auto&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                      \
+      auto&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                      \
+      auto&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                      \
+      ::trompeloeil::ignore(                                                   \
+        _1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15);                   \
+      return __VA_ARGS__;                                                      \
+    })
+
+#else /* (TROMPELOEIL_CPLUSPLUS == 201103L) */
+
+#define TROMPELOEIL_WITH_(capture, arg_s, ...)                                 \
+  with(arg_s, [capture](auto const& trompeloeil_x) {                           \
+    auto& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                         \
+    auto& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                         \
+    auto& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                         \
+    auto& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                         \
+    auto& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                         \
+    auto& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                         \
+    auto& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                         \
+    auto& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                         \
+    auto& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                         \
+    auto&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                        \
+    auto&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                        \
+    auto&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                        \
+    auto&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                        \
+    auto&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                        \
+    auto&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                        \
+    ::trompeloeil::ignore(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15); \
+    return __VA_ARGS__;                                                        \
+  })
+
+#endif /* !(TROMPELOEIL_CPLUSPLUS == 201103L) */
+
+
+#define TROMPELOEIL_SIDE_EFFECT(...)    TROMPELOEIL_SIDE_EFFECT_(=, __VA_ARGS__)
+#define TROMPELOEIL_LR_SIDE_EFFECT(...) TROMPELOEIL_SIDE_EFFECT_(&, __VA_ARGS__)
+
+
+#if (TROMPELOEIL_CPLUSPLUS == 201103L)
+
+#define TROMPELOEIL_SIDE_EFFECT_(capture, ...)                                 \
+  sideeffect(                                                                  \
+    [capture](trompeloeil_e_t::trompeloeil_call_params_type_t& trompeloeil_x) {\
+      auto& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                       \
+      auto& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                       \
+      auto& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                       \
+      auto& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                       \
+      auto& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                       \
+      auto& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                       \
+      auto& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                       \
+      auto& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                       \
+      auto& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                       \
+      auto&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                      \
+      auto&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                      \
+      auto&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                      \
+      auto&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                      \
+      auto&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                      \
+      auto&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                      \
+      ::trompeloeil::ignore(                                                   \
+        _1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15);                   \
+      __VA_ARGS__;                                                             \
+    })
+
+#else /* (TROMPELOEIL_CPLUSPLUS == 201103L) */
+
+#define TROMPELOEIL_SIDE_EFFECT_(capture, ...)                                 \
+  sideeffect([capture](auto& trompeloeil_x) {                                  \
+    auto& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                         \
+    auto& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                         \
+    auto& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                         \
+    auto& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                         \
+    auto& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                         \
+    auto& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                         \
+    auto& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                         \
+    auto& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                         \
+    auto& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                         \
+    auto&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                        \
+    auto&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                        \
+    auto&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                        \
+    auto&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                        \
+    auto&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                        \
+    auto&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                        \
+    ::trompeloeil::ignore(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15); \
+    __VA_ARGS__;                                                               \
+  })
+
+#endif /* !(TROMPELOEIL_CPLUSPLUS == 201103L) */
+
+
+#define TROMPELOEIL_RETURN(...)    TROMPELOEIL_RETURN_(=, __VA_ARGS__)
+#define TROMPELOEIL_LR_RETURN(...) TROMPELOEIL_RETURN_(&, __VA_ARGS__)
+
+
+#if (TROMPELOEIL_CPLUSPLUS == 201103L)
+
+#define TROMPELOEIL_RETURN_(capture, ...)                                      \
+  handle_return(                                                               \
+    [capture](trompeloeil_e_t::trompeloeil_call_params_type_t& trompeloeil_x)  \
+      -> trompeloeil_e_t::trompeloeil_return_of_t                              \
+    {                                                                          \
+      auto& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                       \
+      auto& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                       \
+      auto& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                       \
+      auto& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                       \
+      auto& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                       \
+      auto& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                       \
+      auto& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                       \
+      auto& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                       \
+      auto& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                       \
+      auto&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                      \
+      auto&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                      \
+      auto&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                      \
+      auto&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                      \
+      auto&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                      \
+      auto&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                      \
+      ::trompeloeil::ignore(                                                   \
+        _1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15);                   \
+      return ::trompeloeil::decay_return_type(__VA_ARGS__);                    \
+    })
+
+#else /* (TROMPELOEIL_CPLUSPLUS == 201103L) */
+
+#define TROMPELOEIL_RETURN_(capture, ...)                                      \
+  handle_return([capture](auto& trompeloeil_x) -> decltype(auto) {             \
+    auto& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                         \
+    auto& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                         \
+    auto& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                         \
+    auto& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                         \
+    auto& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                         \
+    auto& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                         \
+    auto& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                         \
+    auto& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                         \
+    auto& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                         \
+    auto&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                        \
+    auto&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                        \
+    auto&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                        \
+    auto&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                        \
+    auto&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                        \
+    auto&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                        \
+    ::trompeloeil::ignore(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15); \
+    return ::trompeloeil::decay_return_type(__VA_ARGS__);                      \
+  })
+
+#endif /* !(TROMPELOEIL_CPLUSPLUS == 201103L) */
+
+
+#define TROMPELOEIL_THROW(...)    TROMPELOEIL_THROW_(=, __VA_ARGS__)
+#define TROMPELOEIL_LR_THROW(...) TROMPELOEIL_THROW_(&, __VA_ARGS__)
+
+
+#if (TROMPELOEIL_CPLUSPLUS == 201103L)
+
+#define TROMPELOEIL_THROW_(capture, ...)                                       \
+  handle_throw(                                                                \
+    [capture](trompeloeil_e_t::trompeloeil_call_params_type_t& trompeloeil_x) {\
+      auto& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                       \
+      auto& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                       \
+      auto& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                       \
+      auto& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                       \
+      auto& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                       \
+      auto& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                       \
+      auto& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                       \
+      auto& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                       \
+      auto& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                       \
+      auto&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                      \
+      auto&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                      \
+      auto&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                      \
+      auto&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                      \
+      auto&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                      \
+      auto&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                      \
+      ::trompeloeil::ignore(                                                   \
+        _1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15);                   \
+      throw __VA_ARGS__;                                                       \
+    })
+
+#else /* (TROMPELOEIL_CPLUSPLUS == 201103L) */
+
+#define TROMPELOEIL_THROW_(capture, ...)                                       \
+  handle_throw([capture](auto& trompeloeil_x)  {                               \
+    auto& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                         \
+    auto& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                         \
+    auto& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                         \
+    auto& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                         \
+    auto& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                         \
+    auto& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                         \
+    auto& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                         \
+    auto& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                         \
+    auto& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                         \
+    auto&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                        \
+    auto&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                        \
+    auto&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                        \
+    auto&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                        \
+    auto&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                        \
+    auto&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                        \
+    ::trompeloeil::ignore(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15); \
+    throw __VA_ARGS__;                                                         \
+ })
+
+#endif /* !(TROMPELOEIL_CPLUSPLUS == 201103L) */
+
+
+#define TROMPELOEIL_TIMES(...) times(::trompeloeil::multiplicity<__VA_ARGS__>{})
+
+#define TROMPELOEIL_IN_SEQUENCE(...)                                           \
+  in_sequence(TROMPELOEIL_INIT_WITH_STR(::trompeloeil::sequence_matcher::init_type, __VA_ARGS__))
+
+#define TROMPELOEIL_ANY(type) ::trompeloeil::any_matcher<type>(#type)
+
+#define TROMPELOEIL_AT_LEAST(num) num, ~0ULL
+#define TROMPELOEIL_AT_MOST(num) 0, num
+
+#define TROMPELOEIL_REQUIRE_DESTRUCTION(obj)                                   \
+  TROMPELOEIL_REQUIRE_DESTRUCTION_(obj, #obj)
+
+#define TROMPELOEIL_REQUIRE_DESTRUCTION_(obj, obj_s)                           \
+  std::unique_ptr<trompeloeil::expectation>                                    \
+    TROMPELOEIL_CONCAT(trompeloeil_death_monitor_, __LINE__)                   \
+    = TROMPELOEIL_NAMED_REQUIRE_DESTRUCTION_(,obj, obj_s)
+
+#define TROMPELOEIL_NAMED_REQUIRE_DESTRUCTION(obj)                             \
+  TROMPELOEIL_NAMED_REQUIRE_DESTRUCTION_("NAMED_", obj, #obj)
+
+#define TROMPELOEIL_NAMED_REQUIRE_DESTRUCTION_(prefix, obj, obj_s)             \
+  trompeloeil::lifetime_monitor_releaser{} +                                   \
+  trompeloeil::lifetime_monitor_modifier<false>{                               \
+    ::trompeloeil::detail::make_unique<trompeloeil::lifetime_monitor>(         \
+      obj,                                                                     \
+      obj_s,                                                                   \
+      prefix "REQUIRE_DESTRUCTION(" obj_s ")",                                 \
+      "destructor for " obj_s,                                                 \
+      ::trompeloeil::location{__FILE__,                                        \
+                              static_cast<unsigned long>(__LINE__)})           \
+  }
+
+#ifndef TROMPELOEIL_LONG_MACROS
+#define MAKE_MOCK0                TROMPELOEIL_MAKE_MOCK0
+#define MAKE_MOCK1                TROMPELOEIL_MAKE_MOCK1
+#define MAKE_MOCK2                TROMPELOEIL_MAKE_MOCK2
+#define MAKE_MOCK3                TROMPELOEIL_MAKE_MOCK3
+#define MAKE_MOCK4                TROMPELOEIL_MAKE_MOCK4
+#define MAKE_MOCK5                TROMPELOEIL_MAKE_MOCK5
+#define MAKE_MOCK6                TROMPELOEIL_MAKE_MOCK6
+#define MAKE_MOCK7                TROMPELOEIL_MAKE_MOCK7
+#define MAKE_MOCK8                TROMPELOEIL_MAKE_MOCK8
+#define MAKE_MOCK9                TROMPELOEIL_MAKE_MOCK9
+#define MAKE_MOCK10               TROMPELOEIL_MAKE_MOCK10
+#define MAKE_MOCK11               TROMPELOEIL_MAKE_MOCK11
+#define MAKE_MOCK12               TROMPELOEIL_MAKE_MOCK12
+#define MAKE_MOCK13               TROMPELOEIL_MAKE_MOCK13
+#define MAKE_MOCK14               TROMPELOEIL_MAKE_MOCK14
+#define MAKE_MOCK15               TROMPELOEIL_MAKE_MOCK15
+
+#define MAKE_CONST_MOCK0          TROMPELOEIL_MAKE_CONST_MOCK0
+#define MAKE_CONST_MOCK1          TROMPELOEIL_MAKE_CONST_MOCK1
+#define MAKE_CONST_MOCK2          TROMPELOEIL_MAKE_CONST_MOCK2
+#define MAKE_CONST_MOCK3          TROMPELOEIL_MAKE_CONST_MOCK3
+#define MAKE_CONST_MOCK4          TROMPELOEIL_MAKE_CONST_MOCK4
+#define MAKE_CONST_MOCK5          TROMPELOEIL_MAKE_CONST_MOCK5
+#define MAKE_CONST_MOCK6          TROMPELOEIL_MAKE_CONST_MOCK6
+#define MAKE_CONST_MOCK7          TROMPELOEIL_MAKE_CONST_MOCK7
+#define MAKE_CONST_MOCK8          TROMPELOEIL_MAKE_CONST_MOCK8
+#define MAKE_CONST_MOCK9          TROMPELOEIL_MAKE_CONST_MOCK9
+#define MAKE_CONST_MOCK10         TROMPELOEIL_MAKE_CONST_MOCK10
+#define MAKE_CONST_MOCK11         TROMPELOEIL_MAKE_CONST_MOCK11
+#define MAKE_CONST_MOCK12         TROMPELOEIL_MAKE_CONST_MOCK12
+#define MAKE_CONST_MOCK13         TROMPELOEIL_MAKE_CONST_MOCK13
+#define MAKE_CONST_MOCK14         TROMPELOEIL_MAKE_CONST_MOCK14
+#define MAKE_CONST_MOCK15         TROMPELOEIL_MAKE_CONST_MOCK15
+
+#define IMPLEMENT_MOCK0           TROMPELOEIL_IMPLEMENT_MOCK0
+#define IMPLEMENT_MOCK1           TROMPELOEIL_IMPLEMENT_MOCK1
+#define IMPLEMENT_MOCK2           TROMPELOEIL_IMPLEMENT_MOCK2
+#define IMPLEMENT_MOCK3           TROMPELOEIL_IMPLEMENT_MOCK3
+#define IMPLEMENT_MOCK4           TROMPELOEIL_IMPLEMENT_MOCK4
+#define IMPLEMENT_MOCK5           TROMPELOEIL_IMPLEMENT_MOCK5
+#define IMPLEMENT_MOCK6           TROMPELOEIL_IMPLEMENT_MOCK6
+#define IMPLEMENT_MOCK7           TROMPELOEIL_IMPLEMENT_MOCK7
+#define IMPLEMENT_MOCK8           TROMPELOEIL_IMPLEMENT_MOCK8
+#define IMPLEMENT_MOCK9           TROMPELOEIL_IMPLEMENT_MOCK9
+#define IMPLEMENT_MOCK10          TROMPELOEIL_IMPLEMENT_MOCK10
+#define IMPLEMENT_MOCK11          TROMPELOEIL_IMPLEMENT_MOCK11
+#define IMPLEMENT_MOCK12          TROMPELOEIL_IMPLEMENT_MOCK12
+#define IMPLEMENT_MOCK13          TROMPELOEIL_IMPLEMENT_MOCK13
+#define IMPLEMENT_MOCK14          TROMPELOEIL_IMPLEMENT_MOCK14
+#define IMPLEMENT_MOCK15          TROMPELOEIL_IMPLEMENT_MOCK15
+
+#define IMPLEMENT_CONST_MOCK0     TROMPELOEIL_IMPLEMENT_CONST_MOCK0
+#define IMPLEMENT_CONST_MOCK1     TROMPELOEIL_IMPLEMENT_CONST_MOCK1
+#define IMPLEMENT_CONST_MOCK2     TROMPELOEIL_IMPLEMENT_CONST_MOCK2
+#define IMPLEMENT_CONST_MOCK3     TROMPELOEIL_IMPLEMENT_CONST_MOCK3
+#define IMPLEMENT_CONST_MOCK4     TROMPELOEIL_IMPLEMENT_CONST_MOCK4
+#define IMPLEMENT_CONST_MOCK5     TROMPELOEIL_IMPLEMENT_CONST_MOCK5
+#define IMPLEMENT_CONST_MOCK6     TROMPELOEIL_IMPLEMENT_CONST_MOCK6
+#define IMPLEMENT_CONST_MOCK7     TROMPELOEIL_IMPLEMENT_CONST_MOCK7
+#define IMPLEMENT_CONST_MOCK8     TROMPELOEIL_IMPLEMENT_CONST_MOCK8
+#define IMPLEMENT_CONST_MOCK9     TROMPELOEIL_IMPLEMENT_CONST_MOCK9
+#define IMPLEMENT_CONST_MOCK10    TROMPELOEIL_IMPLEMENT_CONST_MOCK10
+#define IMPLEMENT_CONST_MOCK11    TROMPELOEIL_IMPLEMENT_CONST_MOCK11
+#define IMPLEMENT_CONST_MOCK12    TROMPELOEIL_IMPLEMENT_CONST_MOCK12
+#define IMPLEMENT_CONST_MOCK13    TROMPELOEIL_IMPLEMENT_CONST_MOCK13
+#define IMPLEMENT_CONST_MOCK14    TROMPELOEIL_IMPLEMENT_CONST_MOCK14
+#define IMPLEMENT_CONST_MOCK15    TROMPELOEIL_IMPLEMENT_CONST_MOCK15
+
+#define REQUIRE_CALL_V            TROMPELOEIL_REQUIRE_CALL_V
+#define NAMED_REQUIRE_CALL_V      TROMPELOEIL_NAMED_REQUIRE_CALL_V
+#define ALLOW_CALL_V              TROMPELOEIL_ALLOW_CALL_V
+#define NAMED_ALLOW_CALL_V        TROMPELOEIL_NAMED_ALLOW_CALL_V
+#define FORBID_CALL_V             TROMPELOEIL_FORBID_CALL_V
+#define NAMED_FORBID_CALL_V       TROMPELOEIL_NAMED_FORBID_CALL_V
+
+#if (TROMPELOEIL_CPLUSPLUS > 201103L)
+
+#define REQUIRE_CALL              TROMPELOEIL_REQUIRE_CALL
+#define NAMED_REQUIRE_CALL        TROMPELOEIL_NAMED_REQUIRE_CALL
+#define ALLOW_CALL                TROMPELOEIL_ALLOW_CALL
+#define NAMED_ALLOW_CALL          TROMPELOEIL_NAMED_ALLOW_CALL
+#define FORBID_CALL               TROMPELOEIL_FORBID_CALL
+#define NAMED_FORBID_CALL         TROMPELOEIL_NAMED_FORBID_CALL
+
+#endif /* (TROMPELOEIL_CPLUSPLUS > 201103L) */
+
+#define WITH                      TROMPELOEIL_WITH
+#define LR_WITH                   TROMPELOEIL_LR_WITH
+#define SIDE_EFFECT               TROMPELOEIL_SIDE_EFFECT
+#define LR_SIDE_EFFECT            TROMPELOEIL_LR_SIDE_EFFECT
+#define RETURN                    TROMPELOEIL_RETURN
+#define LR_RETURN                 TROMPELOEIL_LR_RETURN
+#define THROW                     TROMPELOEIL_THROW
+#define LR_THROW                  TROMPELOEIL_LR_THROW
+
+#define TIMES                     TROMPELOEIL_TIMES
+#define IN_SEQUENCE               TROMPELOEIL_IN_SEQUENCE
+#define ANY                       TROMPELOEIL_ANY
+#define AT_LEAST                  TROMPELOEIL_AT_LEAST
+#define AT_MOST                   TROMPELOEIL_AT_MOST
+#define REQUIRE_DESTRUCTION       TROMPELOEIL_REQUIRE_DESTRUCTION
+#define NAMED_REQUIRE_DESTRUCTION TROMPELOEIL_NAMED_REQUIRE_DESTRUCTION
+
+#endif // TROMPELOEIL_LONG_MACROS
+
+#endif // include guard

From 58ccfd51e80f5bf0a1c08e947e031f066d5869e0 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Thu, 6 Jun 2019 22:15:10 +0100
Subject: [PATCH 58/97] Add builder class to encapsulate trompeloeil setup

---
 include/audio_backend/__asio_audio_device.h |  2 +-
 test/asio_test.cpp                          | 76 ++++++++++++++++++++-
 2 files changed, 76 insertions(+), 2 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 10c640e..a4ba153 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -210,7 +210,7 @@ class audio_device final {
   }
 
   void query_io(const audio_direction direction) {
-    const auto result = _asio->getChannels(&_num_inputs, &_num_outputs);
+    auto result = _asio->getChannels(&_num_inputs, &_num_outputs);
 
     if (result != ASE_OK) {
       return;
diff --git a/test/asio_test.cpp b/test/asio_test.cpp
index febdbea..26eee98 100644
--- a/test/asio_test.cpp
+++ b/test/asio_test.cpp
@@ -4,13 +4,14 @@
 // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
 
 #include <audio>
-#include <array>
 #include "catch/catch.hpp"
 #include "catch/trompeloeil.hpp"
 #include "trompeloeil.hpp"
 
 using namespace std::experimental;
 
+using trompeloeil::_;
+
 TEST_CASE("Converts floating point samples to integer samples", "[asio]")
 {
   SECTION("Converts to 32-bit samples")
@@ -114,3 +115,76 @@ class mock_asio : public trompeloeil::mock_interface<IASIO>
   IMPLEMENT_MOCK2(future);
   IMPLEMENT_MOCK0(outputReady);
 };
+
+class asio_device_builder
+{
+public:
+  asio_device_builder(mock_asio& asio) : asio(asio)
+  {}
+
+  using audio_device_ptr = std::unique_ptr<audio_device, std::function<void(audio_device*)>>;
+
+  audio_device_ptr operator()()
+  {
+    REQUIRE_CALL(asio, AddRef()).RETURN(1);
+
+    constexpr long  num_channels{ 2 };
+    REQUIRE_CALL(asio, getChannels(_, _))
+      .SIDE_EFFECT(*_1 = num_channels)
+      .SIDE_EFFECT(*_2 = num_channels)
+      .RETURN(0);
+
+    constexpr long min_buffer_size{ 128 };
+    constexpr long max_buffer_size{ 512 };
+    constexpr long preferred_buffer_size{ 256 };
+    constexpr long granularity{ -1 };
+    REQUIRE_CALL(asio, getBufferSize(_, _, _, _))
+      .SIDE_EFFECT(*_1 = min_buffer_size)
+      .SIDE_EFFECT(*_2 = max_buffer_size)
+      .SIDE_EFFECT(*_3 = preferred_buffer_size)
+      .SIDE_EFFECT(*_3 = granularity)
+      .RETURN(0);
+
+    ASIOChannelInfo info{};
+    REQUIRE_CALL(asio, getChannelInfo(_))
+      .SIDE_EFFECT(*_1 = info)
+      .RETURN(0);
+
+    REQUIRE_CALL(asio, canSampleRate(_))
+      .TIMES(6)
+      .RETURN(ASIOTrue);
+
+    constexpr double sample_rate{ 44'100.0 };
+    REQUIRE_CALL(asio, getSampleRate(_))
+      .SIDE_EFFECT(*_1 = sample_rate)
+      .TIMES(AT_LEAST(1))
+      .RETURN(ASIOTrue);
+
+    return {new audio_device(id, name, &asio, direction), [&](auto* device) {
+      REQUIRE_CALL(asio, stop()).RETURN(ASIOTrue);
+      REQUIRE_CALL(asio, Release()).RETURN(0);
+      delete device;
+    }};
+  }
+
+private:
+  mock_asio& asio;
+  audio_device::device_id_t id{ 0 };
+  std::string name;
+  audio_direction direction{ audio_direction::full_duplex };
+};
+
+class asio_device_fixture
+{
+public:
+  mock_asio asio;
+  asio_device_builder make_asio_device{asio};
+};
+
+TEST_CASE_METHOD(asio_device_fixture, "Creates device with default id", "[asio]")
+{
+  auto device = make_asio_device();
+
+  CHECK(device->device_id() == 0);
+}
+

From b92ce77affacda34d3abaa28be1a59403fe41861 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sat, 8 Jun 2019 11:06:27 +0100
Subject: [PATCH 59/97] Add tests for number of channels

---
 test/asio_test.cpp | 125 ++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 117 insertions(+), 8 deletions(-)

diff --git a/test/asio_test.cpp b/test/asio_test.cpp
index 26eee98..ccc4480 100644
--- a/test/asio_test.cpp
+++ b/test/asio_test.cpp
@@ -128,10 +128,9 @@ class asio_device_builder
   {
     REQUIRE_CALL(asio, AddRef()).RETURN(1);
 
-    constexpr long  num_channels{ 2 };
     REQUIRE_CALL(asio, getChannels(_, _))
-      .SIDE_EFFECT(*_1 = num_channels)
-      .SIDE_EFFECT(*_2 = num_channels)
+      .SIDE_EFFECT(*_1 = num_inputs)
+      .SIDE_EFFECT(*_2 = num_outputs)
       .RETURN(0);
 
     constexpr long min_buffer_size{ 128 };
@@ -167,11 +166,44 @@ class asio_device_builder
     }};
   }
 
+  asio_device_builder& with_id(const audio_device::device_id_t new_id) {
+    id = new_id;
+    return *this;
+  }
+
+  asio_device_builder& with_name(const std::string& new_name) {
+    name = new_name;
+    return *this;
+  }
+
+  asio_device_builder& with_num_input_channels(const long new_num_inputs) {
+    num_inputs = new_num_inputs;
+    return *this;
+  }
+
+  asio_device_builder& with_num_output_channels(const long new_num_outputs) {
+    num_outputs = new_num_outputs;
+    return *this;
+  }
+
+  asio_device_builder& using_inputs_only() {
+    direction = audio_direction::in;
+    return *this;
+  }
+
+  asio_device_builder& using_outputs_only() {
+    direction = audio_direction::out;
+    return *this;
+  }
+
 private:
   mock_asio& asio;
-  audio_device::device_id_t id{ 0 };
+  audio_device::device_id_t id{0};
   std::string name;
-  audio_direction direction{ audio_direction::full_duplex };
+  audio_direction direction{audio_direction::full_duplex};
+
+  long num_inputs{0};
+  long num_outputs{0};
 };
 
 class asio_device_fixture
@@ -181,10 +213,87 @@ class asio_device_fixture
   asio_device_builder make_asio_device{asio};
 };
 
-TEST_CASE_METHOD(asio_device_fixture, "Creates device with default id", "[asio]")
+TEST_CASE_METHOD(asio_device_fixture, "Creates device with id", "[asio]")
+{
+  auto device = make_asio_device.with_id(42)();
+
+  CHECK(device->device_id() == 42);
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Creates device with name", "[asio]")
+{
+  auto device = make_asio_device.with_name("Fake ASIO")();
+
+  CHECK(device->name() == "Fake ASIO");
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Creates stereo output device", "[asio]")
+{
+  auto device = make_asio_device.with_num_output_channels(2)();
+
+  CHECK(device->is_output());
+  CHECK(device->get_num_output_channels() == 2);
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Creates mono output device", "[asio]")
+{
+  auto device = make_asio_device.with_num_output_channels(1)();
+
+  CHECK(device->is_output());
+  CHECK(device->get_num_output_channels() == 1);
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Creates stereo input device", "[asio]")
+{
+  auto device = make_asio_device.with_num_input_channels(2)();
+
+  CHECK(device->is_input());
+  CHECK(device->get_num_input_channels() == 2);
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Creates mono input device", "[asio]")
+{
+  auto device = make_asio_device.with_num_input_channels(1)();
+
+  CHECK(device->is_input());
+  CHECK(device->get_num_input_channels() == 1);
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Creates full duplex device", "[asio]")
+{
+  auto device = make_asio_device
+    .with_num_input_channels(4)
+    .with_num_output_channels(4)();
+
+  CHECK(device->is_input());
+  CHECK(device->get_num_input_channels() == 4);
+  CHECK(device->is_output());
+  CHECK(device->get_num_output_channels() == 4);
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Creates input-only device from duplex ASIO", "[asio]")
+{
+  auto device = make_asio_device
+    .with_num_input_channels(4)
+    .with_num_output_channels(4)
+    .using_inputs_only()();
+
+  CHECK(device->is_input());
+  CHECK(device->get_num_input_channels() == 4);
+  CHECK_FALSE(device->is_output());
+  CHECK(device->get_num_output_channels() == 0);
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Creates output-only device from duplex ASIO", "[asio]")
 {
-  auto device = make_asio_device();
+  auto device = make_asio_device
+    .with_num_input_channels(4)
+    .with_num_output_channels(4)
+    .using_outputs_only()();
 
-  CHECK(device->device_id() == 0);
+  CHECK_FALSE(device->is_input());
+  CHECK(device->get_num_input_channels() == 0);
+  CHECK(device->is_output());
+  CHECK(device->get_num_output_channels() == 4);
 }
 

From f75abfad32d9de79dd329c8387deffea742d6572 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sat, 8 Jun 2019 12:50:32 +0100
Subject: [PATCH 60/97] Add tests for buffer sizes

---
 test/asio_test.cpp | 89 +++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 84 insertions(+), 5 deletions(-)

diff --git a/test/asio_test.cpp b/test/asio_test.cpp
index ccc4480..810e5d0 100644
--- a/test/asio_test.cpp
+++ b/test/asio_test.cpp
@@ -11,6 +11,7 @@
 using namespace std::experimental;
 
 using trompeloeil::_;
+using buffer_size_t = audio_device::buffer_size_t;
 
 TEST_CASE("Converts floating point samples to integer samples", "[asio]")
 {
@@ -133,15 +134,11 @@ class asio_device_builder
       .SIDE_EFFECT(*_2 = num_outputs)
       .RETURN(0);
 
-    constexpr long min_buffer_size{ 128 };
-    constexpr long max_buffer_size{ 512 };
-    constexpr long preferred_buffer_size{ 256 };
-    constexpr long granularity{ -1 };
     REQUIRE_CALL(asio, getBufferSize(_, _, _, _))
       .SIDE_EFFECT(*_1 = min_buffer_size)
       .SIDE_EFFECT(*_2 = max_buffer_size)
       .SIDE_EFFECT(*_3 = preferred_buffer_size)
-      .SIDE_EFFECT(*_3 = granularity)
+      .SIDE_EFFECT(*_4 = granularity)
       .RETURN(0);
 
     ASIOChannelInfo info{};
@@ -196,6 +193,31 @@ class asio_device_builder
     return *this;
   }
 
+  asio_device_builder& with_unique_buffer_size(const long buffer_size) {
+    min_buffer_size = max_buffer_size = preferred_buffer_size = buffer_size;
+    granularity = 0;
+    return *this;
+  }
+
+  asio_device_builder& with_power_of_two_buffer_sizes(const long min, const long max) {
+    min_buffer_size = min;
+    max_buffer_size = max;
+    granularity = -1;
+    return *this;
+  }
+
+  asio_device_builder& with_preferred_buffer_size(const long preferred) {
+    preferred_buffer_size = preferred;
+    return *this;
+  }
+
+  asio_device_builder& with_buffer_size_range(const long min, const long max, const long step) {
+    min_buffer_size = min;
+    max_buffer_size = max;
+    granularity = step;
+    return *this;
+  }
+
 private:
   mock_asio& asio;
   audio_device::device_id_t id{0};
@@ -204,6 +226,11 @@ class asio_device_builder
 
   long num_inputs{0};
   long num_outputs{0};
+
+  long min_buffer_size{128};
+  long max_buffer_size{512};
+  long preferred_buffer_size{256};
+  long granularity{-1};
 };
 
 class asio_device_fixture
@@ -297,3 +324,55 @@ TEST_CASE_METHOD(asio_device_fixture, "Creates output-only device from duplex AS
   CHECK(device->get_num_output_channels() == 4);
 }
 
+TEST_CASE_METHOD(asio_device_fixture, "Supports unique buffer size", "[asio]")
+{
+  auto device = make_asio_device.with_unique_buffer_size(1024)();
+
+  auto buffer_sizes = device->get_supported_buffer_sizes_frames();
+
+  CHECK(buffer_sizes.size() == 1);
+  CHECK(buffer_sizes[0] == 1024);
+  CHECK(device->get_buffer_size_frames() == 1024);
+  CHECK(device->set_buffer_size_frames(1024));
+  CHECK_FALSE(device->set_buffer_size_frames(64));
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Supports power-of-two buffer sizes", "[asio]")
+{
+  const std::array<buffer_size_t, 5> expected_buffer_sizes{64, 128, 256, 512, 1024};
+
+  auto device = make_asio_device
+    .with_power_of_two_buffer_sizes(64, 1024)
+    .with_preferred_buffer_size(256)();
+
+  const auto buffer_sizes = device->get_supported_buffer_sizes_frames();
+  CHECK(buffer_sizes == span<const buffer_size_t>(expected_buffer_sizes));
+  CHECK(device->get_buffer_size_frames() == 256);
+
+  for (const auto size : expected_buffer_sizes) {
+    CHECK(device->set_buffer_size_frames(size));
+    CHECK_FALSE(device->set_buffer_size_frames(size + 1));
+    CHECK_FALSE(device->set_buffer_size_frames(size - 1));
+    CHECK(device->get_buffer_size_frames() == size);
+  }
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Supports buffer size ranges", "[asio]")
+{
+  const std::array<buffer_size_t, 4> expected_buffer_sizes{64, 128, 192, 256};
+
+  auto device = make_asio_device
+    .with_buffer_size_range(64, 256, 64)
+    .with_preferred_buffer_size(192)();
+
+  const auto buffer_sizes = device->get_supported_buffer_sizes_frames();
+  CHECK(buffer_sizes == span<const buffer_size_t>(expected_buffer_sizes));
+  CHECK(device->get_buffer_size_frames() == 192);
+
+  for (const auto size : expected_buffer_sizes) {
+    CHECK(device->set_buffer_size_frames(size));
+    CHECK_FALSE(device->set_buffer_size_frames(size + 1));
+    CHECK_FALSE(device->set_buffer_size_frames(size - 1));
+    CHECK(device->get_buffer_size_frames() == size);
+  }
+}

From 39eba30e29f3e56e1e828ab7060dc10f8983da03 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sat, 8 Jun 2019 14:18:19 +0100
Subject: [PATCH 61/97] Set sensible default for ASIOInfo

---
 test/asio_test.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/asio_test.cpp b/test/asio_test.cpp
index 810e5d0..3bcc972 100644
--- a/test/asio_test.cpp
+++ b/test/asio_test.cpp
@@ -141,7 +141,6 @@ class asio_device_builder
       .SIDE_EFFECT(*_4 = granularity)
       .RETURN(0);
 
-    ASIOChannelInfo info{};
     REQUIRE_CALL(asio, getChannelInfo(_))
       .SIDE_EFFECT(*_1 = info)
       .RETURN(0);
@@ -231,6 +230,7 @@ class asio_device_builder
   long max_buffer_size{512};
   long preferred_buffer_size{256};
   long granularity{-1};
+  ASIOChannelInfo info{0, ASIOFalse, ASIOFalse, 0, ASIOSTInt32LSB};
 };
 
 class asio_device_fixture

From ec35635badba1258ce71b22ffd43adb32c019dea Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sat, 8 Jun 2019 14:52:48 +0100
Subject: [PATCH 62/97] Add tests for sample rates

---
 test/asio_test.cpp | 50 +++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 49 insertions(+), 1 deletion(-)

diff --git a/test/asio_test.cpp b/test/asio_test.cpp
index 3bcc972..dc26779 100644
--- a/test/asio_test.cpp
+++ b/test/asio_test.cpp
@@ -11,6 +11,8 @@
 using namespace std::experimental;
 
 using trompeloeil::_;
+
+using sample_rate_t = audio_device::sample_rate_t;
 using buffer_size_t = audio_device::buffer_size_t;
 
 TEST_CASE("Converts floating point samples to integer samples", "[asio]")
@@ -147,7 +149,7 @@ class asio_device_builder
 
     REQUIRE_CALL(asio, canSampleRate(_))
       .TIMES(6)
-      .RETURN(ASIOTrue);
+      .RETURN(is_supported_sample_rate(_1));
 
     constexpr double sample_rate{ 44'100.0 };
     REQUIRE_CALL(asio, getSampleRate(_))
@@ -162,6 +164,12 @@ class asio_device_builder
     }};
   }
 
+  long is_supported_sample_rate(const sample_rate_t rate) const {
+    return std::find(sample_rates.begin(), sample_rates.end(), rate) == sample_rates.end()
+      ? ASE_NotPresent
+      : ASE_OK;
+  }
+
   asio_device_builder& with_id(const audio_device::device_id_t new_id) {
     id = new_id;
     return *this;
@@ -217,6 +225,11 @@ class asio_device_builder
     return *this;
   }
 
+  asio_device_builder& with_sample_rates(std::vector<sample_rate_t> new_sample_rates) {
+    sample_rates = new_sample_rates;
+    return *this;
+  }
+
 private:
   mock_asio& asio;
   audio_device::device_id_t id{0};
@@ -231,6 +244,8 @@ class asio_device_builder
   long preferred_buffer_size{256};
   long granularity{-1};
   ASIOChannelInfo info{0, ASIOFalse, ASIOFalse, 0, ASIOSTInt32LSB};
+
+  std::vector<sample_rate_t> sample_rates{44'100, 48'000, 88'200, 96'000, 176'400, 192'000};
 };
 
 class asio_device_fixture
@@ -376,3 +391,36 @@ TEST_CASE_METHOD(asio_device_fixture, "Supports buffer size ranges", "[asio]")
     CHECK(device->get_buffer_size_frames() == size);
   }
 }
+
+TEST_CASE_METHOD(asio_device_fixture, "Supports common samplerates", "[asio]")
+{
+  const std::array<sample_rate_t, 6>
+    expected_sample_rates{44'100, 48'000, 88'200, 96'000, 176'400, 192'000};
+
+  auto device = make_asio_device();
+
+  const auto sample_rates = device->get_supported_sample_rates();
+  CHECK(sample_rates == span<const sample_rate_t>(expected_sample_rates));
+
+  for (const auto rate : expected_sample_rates) {
+    ALLOW_CALL(asio, setSampleRate(_)).RETURN(make_asio_device.is_supported_sample_rate(rate));
+    CHECK(device->set_sample_rate(rate));
+  }
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Supports subset of common samplerates", "[asio]")
+{
+  const std::vector<sample_rate_t> expected_sample_rates{44'100, 48'000};
+
+  auto device = make_asio_device.with_sample_rates(expected_sample_rates)();
+
+  const auto sample_rates = device->get_supported_sample_rates();
+  CHECK(sample_rates == span<const sample_rate_t>(expected_sample_rates));
+
+  const std::array<sample_rate_t, 4> banned_sample_rates{88'200, 96'000, 176'400, 192'000};
+  for (const auto rate : banned_sample_rates) {
+    ALLOW_CALL(asio, setSampleRate(_)).RETURN(make_asio_device.is_supported_sample_rate(rate));
+    CHECK_FALSE(device->set_sample_rate(rate));
+  }
+}
+

From 457c26e8a62d650507c451643231f9bf1883844c Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sat, 8 Jun 2019 16:13:45 +0100
Subject: [PATCH 63/97] Add property tests

---
 test/asio_test.cpp | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/test/asio_test.cpp b/test/asio_test.cpp
index dc26779..fca69eb 100644
--- a/test/asio_test.cpp
+++ b/test/asio_test.cpp
@@ -424,3 +424,24 @@ TEST_CASE_METHOD(asio_device_fixture, "Supports subset of common samplerates", "
   }
 }
 
+TEST_CASE_METHOD(asio_device_fixture, "Can connect to device", "[asio]")
+{
+  auto device = make_asio_device();
+
+  CHECK(device->can_connect());
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Cannot poll device", "[asio]")
+{
+  auto device = make_asio_device();
+
+  CHECK_FALSE(device->can_process());
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Device is not running before connection", "[asio]")
+{
+  auto device = make_asio_device();
+
+  CHECK_FALSE(device->is_running());
+}
+

From 23255418e0a05ffc888e0a495b404e9ee4e8c5f8 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sat, 8 Jun 2019 16:21:07 +0100
Subject: [PATCH 64/97] Return false if start is called before client has
 connected

---
 test/asio_test.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/test/asio_test.cpp b/test/asio_test.cpp
index fca69eb..56330ae 100644
--- a/test/asio_test.cpp
+++ b/test/asio_test.cpp
@@ -445,3 +445,10 @@ TEST_CASE_METHOD(asio_device_fixture, "Device is not running before connection",
   CHECK_FALSE(device->is_running());
 }
 
+TEST_CASE_METHOD(asio_device_fixture, "Device cannot be started before connection", "[asio]")
+{
+  auto device = make_asio_device();
+
+  CHECK_FALSE(device->start());
+}
+

From d0c842ad94282ddee45a415bee81c8e20f9be6e6 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sat, 8 Jun 2019 17:17:25 +0100
Subject: [PATCH 65/97] Add test for legacy playback

---
 test/asio_test.cpp | 52 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)

diff --git a/test/asio_test.cpp b/test/asio_test.cpp
index 56330ae..8bd0358 100644
--- a/test/asio_test.cpp
+++ b/test/asio_test.cpp
@@ -160,6 +160,7 @@ class asio_device_builder
     return {new audio_device(id, name, &asio, direction), [&](auto* device) {
       REQUIRE_CALL(asio, stop()).RETURN(ASIOTrue);
       REQUIRE_CALL(asio, Release()).RETURN(0);
+      ALLOW_CALL(asio, disposeBuffers()).RETURN(0);
       delete device;
     }};
   }
@@ -253,6 +254,21 @@ class asio_device_fixture
 public:
   mock_asio asio;
   asio_device_builder make_asio_device{asio};
+
+  ASIOCallbacks* callbacks;
+  ASIOBufferInfo* asio_buffers;
+  std::vector<int32_t> buffer;
+
+  void allocate_buffers(const uint32_t num_channels, const uint32_t num_frames) {
+    buffer.resize(2 * num_channels * num_frames);
+    auto p = buffer.data();
+    for (uint32_t c = 0; c < num_channels; ++c) {
+      for (uint32_t i = 0; i < 2; ++i) {
+        asio_buffers[c].buffers[i] = p;
+        p += num_frames;
+      }
+    }
+  }
 };
 
 TEST_CASE_METHOD(asio_device_fixture, "Creates device with id", "[asio]")
@@ -452,3 +468,39 @@ TEST_CASE_METHOD(asio_device_fixture, "Device cannot be started before connectio
   CHECK_FALSE(device->start());
 }
 
+TEST_CASE_METHOD(asio_device_fixture, "Device writes outputs from legacy callbacks", "[asio]")
+{
+  constexpr long num_channels{2};
+  constexpr long num_frames{32};
+  auto device = make_asio_device
+    .with_num_output_channels(num_channels)
+    .with_unique_buffer_size(num_frames)();
+
+  REQUIRE_CALL(asio, createBuffers(_, _, _, _))
+    .LR_SIDE_EFFECT(asio_buffers = _1)
+    .LR_SIDE_EFFECT(callbacks = _4)
+    .RETURN(0);
+
+  device->connect([&](audio_device& d, audio_device_io<float>& io) mutable noexcept {
+    CHECK(device.get() == &d);
+    auto& out = *io.output_buffer;
+    CHECK(io.output_buffer.has_value());
+    CHECK(out.size_channels() == num_channels);
+    for (int frame = 0; frame < out.size_frames(); ++frame) {
+      out(frame, 0) = 1.0f;
+      out(frame, 1) = -1.0f;
+    }
+  });
+
+  allocate_buffers(num_channels, num_frames);
+
+  REQUIRE_CALL(asio, start()).RETURN(0);
+  REQUIRE_CALL(asio, outputReady()).RETURN(0);
+  CHECK(device->start());
+  callbacks->bufferSwitch(0, ASIOFalse);
+
+  auto value = static_cast<int32_t*>(asio_buffers[0].buffers[0]);
+  CHECK(*value == 0x7fff'ffff);
+  value = static_cast<int32_t*>(asio_buffers[1].buffers[0]);
+  CHECK(*value == -0x7fff'ffff);
+}

From 880db1d7e4d04720f266e1f32ac6bbea56cf7748 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sat, 8 Jun 2019 21:37:06 +0100
Subject: [PATCH 66/97] Add test for timestamped playback

---
 test/asio_test.cpp | 42 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/test/asio_test.cpp b/test/asio_test.cpp
index 8bd0358..840054e 100644
--- a/test/asio_test.cpp
+++ b/test/asio_test.cpp
@@ -504,3 +504,45 @@ TEST_CASE_METHOD(asio_device_fixture, "Device writes outputs from legacy callbac
   value = static_cast<int32_t*>(asio_buffers[1].buffers[0]);
   CHECK(*value == -0x7fff'ffff);
 }
+
+TEST_CASE_METHOD(asio_device_fixture, "Device writes outputs from timestamped callbacks", "[asio]")
+{
+  constexpr long num_channels{2};
+  constexpr long num_frames{32};
+  auto device = make_asio_device
+    .with_num_output_channels(num_channels)
+    .with_unique_buffer_size(num_frames)();
+
+  REQUIRE_CALL(asio, createBuffers(_, _, _, _))
+    .LR_SIDE_EFFECT(asio_buffers = _1)
+    .LR_SIDE_EFFECT(callbacks = _4)
+    .RETURN(0);
+
+  device->connect([&](audio_device& d, audio_device_io<float>& io) mutable noexcept {
+    CHECK(device.get() == &d);
+    auto& out = *io.output_buffer;
+    CHECK(io.output_buffer.has_value());
+    CHECK(out.size_channels() == num_channels);
+    for (int frame = 0; frame < out.size_frames(); ++frame) {
+      out(frame, 0) = 1.0f;
+      out(frame, 1) = -1.0f;
+    }
+  });
+
+  allocate_buffers(num_channels, num_frames);
+
+  REQUIRE_CALL(asio, start()).RETURN(0);
+  CHECK(device->start());
+
+  ASIOTime time;
+  auto result = callbacks->bufferSwitchTimeInfo(&time, 0, ASIOFalse);
+  CHECK(result->timeInfo.samplePosition == 0);
+
+  result = callbacks->bufferSwitchTimeInfo(&time, 0, ASIOFalse);
+  CHECK(result->timeInfo.samplePosition == num_frames);
+
+  auto value = static_cast<int32_t*>(asio_buffers[0].buffers[0]);
+  CHECK(*value == 0x7fff'ffff);
+  value = static_cast<int32_t*>(asio_buffers[1].buffers[0]);
+  CHECK(*value == -0x7fff'ffff);
+}

From e7c124cae680ff2a7aaf753b6df249d6f666adb6 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sat, 8 Jun 2019 21:53:34 +0100
Subject: [PATCH 67/97] Add test for ASIO message response

---
 test/asio_test.cpp | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/test/asio_test.cpp b/test/asio_test.cpp
index 840054e..3210be3 100644
--- a/test/asio_test.cpp
+++ b/test/asio_test.cpp
@@ -546,3 +546,19 @@ TEST_CASE_METHOD(asio_device_fixture, "Device writes outputs from timestamped ca
   value = static_cast<int32_t*>(asio_buffers[1].buffers[0]);
   CHECK(*value == -0x7fff'ffff);
 }
+
+TEST_CASE_METHOD(asio_device_fixture, "Device responds to ASIO message callback", "[asio]")
+{
+  auto device = make_asio_device();
+
+  REQUIRE_CALL(asio, createBuffers(_, _, _, _))
+    .LR_SIDE_EFFECT(asio_buffers = _1)
+    .LR_SIDE_EFFECT(callbacks = _4)
+    .RETURN(0);
+
+  device->connect([](auto&, auto&) noexcept {});
+
+  CHECK(callbacks->asioMessage(kAsioSupportsTimeInfo, 0, nullptr, nullptr) == ASIOTrue);
+  CHECK(callbacks->asioMessage(kAsioEngineVersion, 0, nullptr, nullptr) == 2);
+  CHECK(callbacks->asioMessage(kAsioSelectorSupported, 0, nullptr, nullptr) == ASIOFalse);
+}

From d35bb32acc573f49877cdb0d236386d49cfef3b4 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sun, 9 Jun 2019 06:36:41 +0100
Subject: [PATCH 68/97] Add some syntactic sugar to playback test

---
 test/asio_test.cpp | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/test/asio_test.cpp b/test/asio_test.cpp
index 3210be3..d625b87 100644
--- a/test/asio_test.cpp
+++ b/test/asio_test.cpp
@@ -269,6 +269,10 @@ class asio_device_fixture
       }
     }
   }
+
+  void verify_out_value(const uint32_t channel, const int32_t value) {
+    CHECK(*static_cast<int32_t*>(asio_buffers[channel].buffers[0]) == value);
+  }
 };
 
 TEST_CASE_METHOD(asio_device_fixture, "Creates device with id", "[asio]")
@@ -499,10 +503,8 @@ TEST_CASE_METHOD(asio_device_fixture, "Device writes outputs from legacy callbac
   CHECK(device->start());
   callbacks->bufferSwitch(0, ASIOFalse);
 
-  auto value = static_cast<int32_t*>(asio_buffers[0].buffers[0]);
-  CHECK(*value == 0x7fff'ffff);
-  value = static_cast<int32_t*>(asio_buffers[1].buffers[0]);
-  CHECK(*value == -0x7fff'ffff);
+  verify_out_value(0, 0x7fff'ffff);
+  verify_out_value(1, -0x7fff'ffff);
 }
 
 TEST_CASE_METHOD(asio_device_fixture, "Device writes outputs from timestamped callbacks", "[asio]")
@@ -541,10 +543,8 @@ TEST_CASE_METHOD(asio_device_fixture, "Device writes outputs from timestamped ca
   result = callbacks->bufferSwitchTimeInfo(&time, 0, ASIOFalse);
   CHECK(result->timeInfo.samplePosition == num_frames);
 
-  auto value = static_cast<int32_t*>(asio_buffers[0].buffers[0]);
-  CHECK(*value == 0x7fff'ffff);
-  value = static_cast<int32_t*>(asio_buffers[1].buffers[0]);
-  CHECK(*value == -0x7fff'ffff);
+  verify_out_value(0, 0x7fff'ffff);
+  verify_out_value(1, -0x7fff'ffff);
 }
 
 TEST_CASE_METHOD(asio_device_fixture, "Device responds to ASIO message callback", "[asio]")

From 66d5a26a539a1afdf3e7cb33b88e38b5b701ba66 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sun, 9 Jun 2019 06:45:45 +0100
Subject: [PATCH 69/97] Add connect method to test fixture

---
 test/asio_test.cpp | 34 +++++++++++++++-------------------
 1 file changed, 15 insertions(+), 19 deletions(-)

diff --git a/test/asio_test.cpp b/test/asio_test.cpp
index d625b87..5584864 100644
--- a/test/asio_test.cpp
+++ b/test/asio_test.cpp
@@ -259,6 +259,15 @@ class asio_device_fixture
   ASIOBufferInfo* asio_buffers;
   std::vector<int32_t> buffer;
 
+  template <typename _CallbackType>
+  void connect(audio_device& device, _CallbackType callback) {
+    REQUIRE_CALL(asio, createBuffers(_, _, _, _))
+      .LR_SIDE_EFFECT(asio_buffers = _1)
+      .LR_SIDE_EFFECT(callbacks = _4)
+      .RETURN(0);
+    device.connect(callback);
+  }
+
   void allocate_buffers(const uint32_t num_channels, const uint32_t num_frames) {
     buffer.resize(2 * num_channels * num_frames);
     auto p = buffer.data();
@@ -480,16 +489,12 @@ TEST_CASE_METHOD(asio_device_fixture, "Device writes outputs from legacy callbac
     .with_num_output_channels(num_channels)
     .with_unique_buffer_size(num_frames)();
 
-  REQUIRE_CALL(asio, createBuffers(_, _, _, _))
-    .LR_SIDE_EFFECT(asio_buffers = _1)
-    .LR_SIDE_EFFECT(callbacks = _4)
-    .RETURN(0);
-
-  device->connect([&](audio_device& d, audio_device_io<float>& io) mutable noexcept {
+  connect(*device, [&](audio_device& d, audio_device_io<float>& io) mutable noexcept {
     CHECK(device.get() == &d);
     auto& out = *io.output_buffer;
     CHECK(io.output_buffer.has_value());
     CHECK(out.size_channels() == num_channels);
+    CHECK(out.size_frames() == num_frames);
     for (int frame = 0; frame < out.size_frames(); ++frame) {
       out(frame, 0) = 1.0f;
       out(frame, 1) = -1.0f;
@@ -501,6 +506,7 @@ TEST_CASE_METHOD(asio_device_fixture, "Device writes outputs from legacy callbac
   REQUIRE_CALL(asio, start()).RETURN(0);
   REQUIRE_CALL(asio, outputReady()).RETURN(0);
   CHECK(device->start());
+
   callbacks->bufferSwitch(0, ASIOFalse);
 
   verify_out_value(0, 0x7fff'ffff);
@@ -515,16 +521,12 @@ TEST_CASE_METHOD(asio_device_fixture, "Device writes outputs from timestamped ca
     .with_num_output_channels(num_channels)
     .with_unique_buffer_size(num_frames)();
 
-  REQUIRE_CALL(asio, createBuffers(_, _, _, _))
-    .LR_SIDE_EFFECT(asio_buffers = _1)
-    .LR_SIDE_EFFECT(callbacks = _4)
-    .RETURN(0);
-
-  device->connect([&](audio_device& d, audio_device_io<float>& io) mutable noexcept {
+  connect(*device, [&](audio_device& d, audio_device_io<float>& io) mutable noexcept {
     CHECK(device.get() == &d);
     auto& out = *io.output_buffer;
     CHECK(io.output_buffer.has_value());
     CHECK(out.size_channels() == num_channels);
+    CHECK(out.size_frames() == num_frames);
     for (int frame = 0; frame < out.size_frames(); ++frame) {
       out(frame, 0) = 1.0f;
       out(frame, 1) = -1.0f;
@@ -550,13 +552,7 @@ TEST_CASE_METHOD(asio_device_fixture, "Device writes outputs from timestamped ca
 TEST_CASE_METHOD(asio_device_fixture, "Device responds to ASIO message callback", "[asio]")
 {
   auto device = make_asio_device();
-
-  REQUIRE_CALL(asio, createBuffers(_, _, _, _))
-    .LR_SIDE_EFFECT(asio_buffers = _1)
-    .LR_SIDE_EFFECT(callbacks = _4)
-    .RETURN(0);
-
-  device->connect([](auto&, auto&) noexcept {});
+  connect(*device, [](auto&, auto&) noexcept {});
 
   CHECK(callbacks->asioMessage(kAsioSupportsTimeInfo, 0, nullptr, nullptr) == ASIOTrue);
   CHECK(callbacks->asioMessage(kAsioEngineVersion, 0, nullptr, nullptr) == 2);

From 7135c2e04eb03a76d4967854c7752faf5c6c6d51 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sun, 9 Jun 2019 07:16:30 +0100
Subject: [PATCH 70/97] Throws exception if connection attempted when already
 running

---
 test/asio_test.cpp | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/test/asio_test.cpp b/test/asio_test.cpp
index 5584864..6c67e07 100644
--- a/test/asio_test.cpp
+++ b/test/asio_test.cpp
@@ -551,10 +551,24 @@ TEST_CASE_METHOD(asio_device_fixture, "Device writes outputs from timestamped ca
 
 TEST_CASE_METHOD(asio_device_fixture, "Device responds to ASIO message callback", "[asio]")
 {
-  auto device = make_asio_device();
+  const auto device = make_asio_device();
   connect(*device, [](auto&, auto&) noexcept {});
 
   CHECK(callbacks->asioMessage(kAsioSupportsTimeInfo, 0, nullptr, nullptr) == ASIOTrue);
   CHECK(callbacks->asioMessage(kAsioEngineVersion, 0, nullptr, nullptr) == 2);
   CHECK(callbacks->asioMessage(kAsioSelectorSupported, 0, nullptr, nullptr) == ASIOFalse);
 }
+
+TEST_CASE_METHOD(asio_device_fixture, "Throws exception if connection attempted when already running", "[asio]")
+{
+  const auto device = make_asio_device
+    .with_num_output_channels(1)
+    .with_unique_buffer_size(1)();
+  const auto no_op = [](auto&, auto&) noexcept {};
+  connect(*device, no_op);
+  REQUIRE_CALL(asio, start()).RETURN(0);
+  CHECK(device->start());
+
+  CHECK(device->is_running());
+  CHECK_THROWS_AS(device->connect(no_op), audio_device_exception);
+}

From 22fea1d78ae5f71c2e7e1b3be686054c202b009a Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sun, 9 Jun 2019 08:17:08 +0100
Subject: [PATCH 71/97] Add test for legacy record

---
 test/asio_test.cpp | 38 +++++++++++++++++++++++++++++++++++++-
 1 file changed, 37 insertions(+), 1 deletion(-)

diff --git a/test/asio_test.cpp b/test/asio_test.cpp
index 6c67e07..b207f41 100644
--- a/test/asio_test.cpp
+++ b/test/asio_test.cpp
@@ -279,9 +279,16 @@ class asio_device_fixture
     }
   }
 
-  void verify_out_value(const uint32_t channel, const int32_t value) {
+  void verify_out_value(const uint32_t channel, const int32_t value) const {
     CHECK(*static_cast<int32_t*>(asio_buffers[channel].buffers[0]) == value);
   }
+
+  void set_input_value(const int channel, const int32_t value) const {
+    auto samples = static_cast<int32_t*>(asio_buffers[channel].buffers[0]);
+    samples[0] = value;
+    samples = static_cast<int32_t*>(asio_buffers[channel].buffers[1]);
+    samples[0] = value;
+  }
 };
 
 TEST_CASE_METHOD(asio_device_fixture, "Creates device with id", "[asio]")
@@ -572,3 +579,32 @@ TEST_CASE_METHOD(asio_device_fixture, "Throws exception if connection attempted
   CHECK(device->is_running());
   CHECK_THROWS_AS(device->connect(no_op), audio_device_exception);
 }
+
+TEST_CASE_METHOD(asio_device_fixture, "Device reads inputs from legacy callbacks", "[asio]")
+{
+  constexpr long num_channels{ 2 };
+  constexpr long num_frames{ 32 };
+  auto device = make_asio_device
+    .with_num_input_channels(num_channels)
+    .with_unique_buffer_size(num_frames)();
+
+  connect(*device, [&](audio_device& d, audio_device_io<float>& io) mutable noexcept {
+    CHECK(device.get() == &d);
+    auto& in = *io.input_buffer;
+    CHECK(io.input_buffer.has_value());
+    CHECK(in.size_channels() == num_channels);
+    CHECK(in.size_frames() == num_frames);
+    CHECK(in(0, 0) == 1.f);
+    CHECK(in(0, 1) == -1.0f);
+  });
+
+  allocate_buffers(num_channels, num_frames);
+  set_input_value(0, 0x7fff'ffff);
+  set_input_value(1, -0x7fff'ffff);
+
+  REQUIRE_CALL(asio, start()).RETURN(0);
+  CHECK(device->start());
+
+  REQUIRE_CALL(asio, outputReady()).RETURN(0);
+  callbacks->bufferSwitch(0, ASIOFalse);
+}

From 42265ee349d316b1cc4ee7ef53caaddd17042755 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sun, 9 Jun 2019 08:31:37 +0100
Subject: [PATCH 72/97] Add test for timestamped record

---
 test/asio_test.cpp | 36 ++++++++++++++++++++++++++++++++++--
 1 file changed, 34 insertions(+), 2 deletions(-)

diff --git a/test/asio_test.cpp b/test/asio_test.cpp
index b207f41..28406ae 100644
--- a/test/asio_test.cpp
+++ b/test/asio_test.cpp
@@ -582,8 +582,8 @@ TEST_CASE_METHOD(asio_device_fixture, "Throws exception if connection attempted
 
 TEST_CASE_METHOD(asio_device_fixture, "Device reads inputs from legacy callbacks", "[asio]")
 {
-  constexpr long num_channels{ 2 };
-  constexpr long num_frames{ 32 };
+  constexpr long num_channels{2};
+  constexpr long num_frames{32};
   auto device = make_asio_device
     .with_num_input_channels(num_channels)
     .with_unique_buffer_size(num_frames)();
@@ -608,3 +608,35 @@ TEST_CASE_METHOD(asio_device_fixture, "Device reads inputs from legacy callbacks
   REQUIRE_CALL(asio, outputReady()).RETURN(0);
   callbacks->bufferSwitch(0, ASIOFalse);
 }
+
+TEST_CASE_METHOD(asio_device_fixture, "Device reads inputs from timestamped callbacks", "[asio]")
+{
+  constexpr long num_channels{2};
+  constexpr long num_frames{32};
+  auto device = make_asio_device
+    .with_num_input_channels(num_channels)
+    .with_unique_buffer_size(num_frames)();
+
+  connect(*device, [&](audio_device& d, audio_device_io<float>& io) mutable noexcept {
+    CHECK(device.get() == &d);
+    auto& in = *io.input_buffer;
+    CHECK(io.input_buffer.has_value());
+    CHECK(in.size_channels() == num_channels);
+    CHECK(in.size_frames() == num_frames);
+    CHECK(in(0, 0) == 1.f);
+    CHECK(in(0, 1) == -1.0f);
+  });
+
+  allocate_buffers(num_channels, num_frames);
+  set_input_value(0, 0x7fff'ffff);
+  set_input_value(1, -0x7fff'ffff);
+
+  REQUIRE_CALL(asio, start()).RETURN(0);
+  CHECK(device->start());
+
+  ASIOTime time;
+  auto result = callbacks->bufferSwitchTimeInfo(&time, 0, ASIOFalse);
+  CHECK(result->timeInfo.samplePosition == 0);
+  result = callbacks->bufferSwitchTimeInfo(&time, 0, ASIOFalse);
+  CHECK(result->timeInfo.samplePosition == num_frames);
+}

From 50f87b73d79a7c2c529f313604d7b5222dd4da2e Mon Sep 17 00:00:00 2001
From: Andy Saul <andycsaul@gmail.com>
Date: Tue, 11 Jun 2019 19:28:42 +0100
Subject: [PATCH 73/97] Do not throw if ASIO reg key is not read

This is to be expected on hosts without ASIO drivers.
If the root ASIO key is not found, enumerating subkeys will fail, so
ASIO devices will not be created
---
 include/audio_backend/__asio_audio_device.h | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index a4ba153..f6a72fa 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -444,11 +444,7 @@ class __reg_key_reader final
 {
 public:
   __reg_key_reader(HKEY key, const string& subkey) {
-    const auto result = RegOpenKeyExA(key, subkey.c_str(), 0, KEY_READ, &_key);
-
-    if (ERROR_SUCCESS != result) {
-      throw runtime_error("Failed to read info from registry: 0x" + result);
-    }
+    RegOpenKeyExA(key, subkey.c_str(), 0, KEY_READ, &_key);
   }
 
   ~__reg_key_reader() {

From f7d65cf778939bc58d61f1b24302341046c309a4 Mon Sep 17 00:00:00 2001
From: Andy Saul <andycsaul@gmail.com>
Date: Tue, 11 Jun 2019 19:53:29 +0100
Subject: [PATCH 74/97] Use method name to convey intent

---
 include/audio_backend/__asio_audio_device.h | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index f6a72fa..1a3a92f 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -553,8 +553,7 @@ class __asio_devices {
         throw audio_device_exception("Failed to open ASIO driver: 0x" + result);
       }
 
-      if (!asio->init(nullptr)) {
-        // Failed call to init, device not connected
+      if (!is_connected(asio)) {
         continue;
       }
 
@@ -575,7 +574,7 @@ class __asio_devices {
     };
   }
 
-  bool is_excluded(string_view name) const {
+  static bool is_excluded(string_view name) {
     if (name == "Realtek ASIO") {
       // Realtek ASIO drivers seem unstable
       // Every other time is IASIO::createBuffers called, it fails with ASE_InvalidMode
@@ -584,6 +583,10 @@ class __asio_devices {
     }
     return false;
   }
+
+  static bool is_connected(IASIO* asio) {
+    return ASIOTrue == asio->init(nullptr);
+  }
 };
 
 _LIBSTDAUDIO_NAMESPACE_END

From fdb0ab19718e42f7395ee59fdd61060cd91b8ced Mon Sep 17 00:00:00 2001
From: Andy Saul <andycsaul@gmail.com>
Date: Tue, 11 Jun 2019 20:36:43 +0100
Subject: [PATCH 75/97] Tidy up __asio_device::enumerate

---
 include/audio_backend/__asio_audio_device.h | 56 +++++++++++++--------
 1 file changed, 34 insertions(+), 22 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 1a3a92f..7c9c227 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -532,37 +532,46 @@ class __asio_devices {
 
   audio_device_list enumerate(audio_direction direction) const {
     audio_device_list devices;
+    _index = 0;
 
-    __reg_key_reader asio_reg(HKEY_LOCAL_MACHINE, R"(software\asio)");
+    for (const auto& name : _asio_reg.subkeys()) {
 
-    int index = 0;
-    for (const auto& name : asio_reg.subkeys()) {
+      auto device = open_device(name, direction);
 
-      if (is_excluded(name)) {
-        continue;
+      if (device) {
+        devices.push_front(move(*device));
       }
-      const auto key = asio_reg.subkey(name);
-      const auto clsid = key.value("CLSID");
+    }
+    return devices;
+  }
 
-      CLSID class_id;
-      CLSIDFromString(CComBSTR(clsid.c_str()), &class_id);
+  optional<audio_device> open_device(const string& name, const audio_direction direction) const {
 
-      CComPtr<IASIO> asio;
-      const auto result = CoCreateInstance(class_id, nullptr, CLSCTX_INPROC_SERVER, class_id, reinterpret_cast<void**>(&asio));
-      if (result) {
-        throw audio_device_exception("Failed to open ASIO driver: 0x" + result);
-      }
+    if (is_excluded(name)) {
+      return {};
+    }
+    const auto key = _asio_reg.subkey(name);
+    const auto value = key.value("CLSID");
 
-      if (!is_connected(asio)) {
-        continue;
-      }
+    CLSID class_id;
+    CLSIDFromString(CComBSTR(value.c_str()), &class_id);
 
-      auto device = audio_device{index++, name, asio, direction};
-      if (is_required(device, direction)) {
-        devices.push_front(move(device));
-      }
+    CComPtr<IASIO> asio;
+    const auto result = CoCreateInstance(class_id, nullptr, CLSCTX_INPROC_SERVER, class_id, reinterpret_cast<void**>(&asio));
+    if (result) {
+      throw audio_device_exception("Failed to open ASIO driver: 0x" + result);
     }
-    return devices;
+
+    if (!is_connected(asio)) {
+      return {};
+    }
+
+    const auto device = audio_device(_index++, name, asio, direction);
+    if (!is_required(device, direction)) {
+      return {};
+    }
+
+    return device;
   }
 
   static bool is_required(const audio_device& device, const audio_direction direction) {
@@ -587,6 +596,9 @@ class __asio_devices {
   static bool is_connected(IASIO* asio) {
     return ASIOTrue == asio->init(nullptr);
   }
+
+  __reg_key_reader _asio_reg{HKEY_LOCAL_MACHINE, R"(software\asio)"};
+  mutable int _index{0};
 };
 
 _LIBSTDAUDIO_NAMESPACE_END

From 931de469edecbc786af6fad9cd32b6b185c33442 Mon Sep 17 00:00:00 2001
From: Andy Saul <andycsaul@gmail.com>
Date: Tue, 11 Jun 2019 21:49:41 +0100
Subject: [PATCH 76/97] Add .clang-format file to keep style consistent

---
 .clang-format                               |  31 ++++++
 include/audio_backend/__asio_audio_device.h | 116 +++++++++-----------
 include/audio_backend/__asio_backend.h      |   2 +-
 include/audio_backend/__asio_sample.h       |  36 ++----
 4 files changed, 97 insertions(+), 88 deletions(-)
 create mode 100644 .clang-format

diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000..a74792e
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,31 @@
+---
+
+BasedOnStyle: LLVM
+
+ColumnLimit: 100          # Arbitrary, feel free to adjust locally. 0 to ignore.
+PenaltyExcessCharacter: 1 # Softest limit on line length.
+ReflowComments: false     # Best we don't do this without a consistent length limit.
+
+AlwaysBreakTemplateDeclarations: true
+
+AllowShortFunctionsOnASingleLine: Empty
+
+SpaceAfterTemplateKeyword: false
+
+ConstructorInitializerIndentWidth: 2
+ContinuationIndentWidth: 2
+IndentWidth: 2
+
+AllowShortCaseLabelsOnASingleLine: true
+
+DerivePointerAlignment: true
+
+IndentCaseLabels: true
+
+BinPackArguments: false
+BinPackParameters: false
+
+---
+Language: Cpp
+
+...
diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 7c9c227..1950f9d 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -9,12 +9,12 @@
 
 #include "iasiodrv.h"
 
-#include <string_view>
-#include <chrono>
 #include <cassert>
+#include <chrono>
 #include <forward_list>
-#include <vector>
 #include <functional>
+#include <string_view>
+#include <vector>
 
 #define WIN32_LEAN_AND_MEAN
 #include <Windows.h>
@@ -25,20 +25,17 @@ _LIBSTDAUDIO_NAMESPACE_BEGIN
 using __asio_common_sample_type = float;
 
 struct audio_device_exception : public runtime_error {
-  explicit audio_device_exception(const char* what)
-    : runtime_error(what) {
-  }
+  explicit audio_device_exception(const char* what) : runtime_error(what) {}
 };
 
-enum class audio_direction {in, out, full_duplex};
+enum class audio_direction { in, out, full_duplex };
 
 class audio_device final {
 public:
   using device_id_t = int;
 
   explicit audio_device(device_id_t id, string name, IASIO* asio, audio_direction direction)
-    : _name(name), _id(id), _asio(asio)
-  {
+    : _name(name), _id(id), _asio(asio) {
     prepare_asio(direction);
   }
 
@@ -109,7 +106,7 @@ class audio_device final {
     return true;
   }
 
-  template <typename _SampleType>
+  template<typename _SampleType>
   constexpr bool supports_sample_type() const noexcept {
     return is_same_v<_SampleType, __asio_common_sample_type>;
   }
@@ -125,10 +122,10 @@ class audio_device final {
   // TODO: remove std::function as soon as C++20 default-ctable lambda and lambda in unevaluated contexts become available
   using no_op_t = std::function<void(audio_device&)>;
 
-  template <typename _StartCallbackType = no_op_t,
-            typename _StopCallbackType = no_op_t,
-            // TODO: is_nothrow_invocable_t does not compile, temporarily replaced with is_invocable_t
-            typename = enable_if_t<is_invocable_v<_StartCallbackType, audio_device&> && is_invocable_v<_StopCallbackType, audio_device&>>>
+  template<typename _StartCallbackType = no_op_t,
+           typename _StopCallbackType = no_op_t,
+           // TODO: is_nothrow_invocable_t does not compile, temporarily replaced with is_invocable_t
+           typename = enable_if_t<is_invocable_v<_StartCallbackType, audio_device&> && is_invocable_v<_StopCallbackType, audio_device&>>>
   bool start(_StartCallbackType&& start_callback = [](audio_device&) noexcept {},
              _StopCallbackType&& stop_callback = [](audio_device&) noexcept {}) {
 
@@ -178,13 +175,12 @@ class audio_device final {
     assert(false);
   }
 
-  template <typename _CallbackType>
+  template<typename _CallbackType>
   void process(_CallbackType&) {
     assert(false);
   }
 
-  template <typename _CallbackType,
-            typename = enable_if_t<is_nothrow_invocable_v<_CallbackType, audio_device&, audio_device_io<float>&>> >
+  template<typename _CallbackType, typename = enable_if_t<is_nothrow_invocable_v<_CallbackType, audio_device&, audio_device_io<float>&>>>
   void connect(_CallbackType callback) {
     if (_running) {
       throw audio_device_exception("cannot connect to running audio_device");
@@ -217,8 +213,8 @@ class audio_device final {
     }
 
     switch (direction) {
-    case audio_direction::in: _num_outputs = 0; break;
-    case audio_direction::out: _num_inputs = 0; break;
+      case audio_direction::in: _num_outputs = 0; break;
+      case audio_direction::out: _num_inputs = 0; break;
     }
 
     long min;
@@ -231,9 +227,9 @@ class audio_device final {
     }
 
     switch (granularity) {
-    default: set_buffers(min, max, granularity); break;
-    case -1: set_buffers_as_powers_of_two(min, max); break;
-    case 0: set_buffers_as_default_size_only(); break;
+      default: set_buffers(min, max, granularity); break;
+      case -1: set_buffers_as_powers_of_two(min, max); break;
+      case 0: set_buffers_as_default_size_only(); break;
     }
 
     set_buffer_size_frames(_buffer_size);
@@ -259,9 +255,8 @@ class audio_device final {
     _buffer_sizes.push_back(_buffer_size);
   }
 
-  void query_sample_rates()
-  {
-    constexpr array<sample_rate_t, 6> common_sample_rates = { 44'100, 48'000, 88'200, 96'000, 176'400, 192'000 };
+  void query_sample_rates() {
+    constexpr array<sample_rate_t, 6> common_sample_rates = {44'100, 48'000, 88'200, 96'000, 176'400, 192'000};
 
     for (const auto sample_rate : common_sample_rates) {
       if (ASE_OK == _asio->canSampleRate(sample_rate)) {
@@ -276,10 +271,10 @@ class audio_device final {
   void allocate_buffers() {
 
     for (int i = 0; i < _num_inputs; ++i) {
-      _asio_buffers.emplace_back(ASIOBufferInfo{ true, i });
+      _asio_buffers.emplace_back(ASIOBufferInfo{true, i});
     }
     for (int i = 0; i < _num_outputs; ++i) {
-      _asio_buffers.emplace_back(ASIOBufferInfo{ false, i });
+      _asio_buffers.emplace_back(ASIOBufferInfo{false, i});
     }
 
     const long num_channels = _num_inputs + _num_outputs;
@@ -305,20 +300,19 @@ class audio_device final {
       return;
     }
 
-    switch (_sample_type)
-    {
-    case ASIOSTInt32LSB: _read = [this](long index) { read<int32_t>(index); }; break;
-    case ASIOSTInt24LSB: _read = [this](long index) { read<packed24_t>(index); }; break;
-    case ASIOSTInt16LSB: _read = [this](long index) { read<int16_t>(index); }; break;
-    case ASIOSTFloat32LSB: _read = [this](long index) { read<float>(index); }; break;
-    case ASIOSTFloat64LSB: _read = [this](long index) { read<double>(index); }; break;
+    switch (_sample_type) {
+      case ASIOSTInt32LSB: _read = [this](long index) { read<int32_t>(index); }; break;
+      case ASIOSTInt24LSB: _read = [this](long index) { read<packed24_t>(index); }; break;
+      case ASIOSTInt16LSB: _read = [this](long index) { read<int16_t>(index); }; break;
+      case ASIOSTFloat32LSB: _read = [this](long index) { read<float>(index); }; break;
+      case ASIOSTFloat64LSB: _read = [this](long index) { read<double>(index); }; break;
 
-    default: throw audio_device_exception("ASIO native sample type not supported: " + _sample_type);
+      default: throw audio_device_exception("ASIO native sample type not supported: " + _sample_type);
     }
   }
 
-  template <typename _SampleType>
-  void read (long index) {
+  template<typename _SampleType>
+  void read(long index) {
 
     auto& in = *_io.input_buffer;
     for (int channel = 0; channel < _num_inputs; ++channel) {
@@ -336,20 +330,19 @@ class audio_device final {
       return;
     }
 
-    switch (_sample_type)
-    {
-    case ASIOSTInt32LSB: _write = [this](long index) { write<int32_t>(index); }; break;
-    case ASIOSTInt24LSB: _write = [this](long index) { write<packed24_t>(index); }; break;
-    case ASIOSTInt16LSB: _write = [this](long index) { write<int16_t>(index); }; break;
-    case ASIOSTFloat32LSB: _write = [this](long index) { write<float>(index); }; break;
-    case ASIOSTFloat64LSB: _write = [this](long index) { write<double>(index); }; break;
+    switch (_sample_type) {
+      case ASIOSTInt32LSB: _write = [this](long index) { write<int32_t>(index); }; break;
+      case ASIOSTInt24LSB: _write = [this](long index) { write<packed24_t>(index); }; break;
+      case ASIOSTInt16LSB: _write = [this](long index) { write<int16_t>(index); }; break;
+      case ASIOSTFloat32LSB: _write = [this](long index) { write<float>(index); }; break;
+      case ASIOSTFloat64LSB: _write = [this](long index) { write<double>(index); }; break;
 
-    default: throw audio_device_exception("ASIO native sample type not supported: " + _sample_type);
+      default: throw audio_device_exception("ASIO native sample type not supported: " + _sample_type);
     }
   }
 
-  template <typename _SampleType>
-  void write (long index) {
+  template<typename _SampleType>
+  void write(long index) {
 
     auto& out = *_io.output_buffer;
     for (int channel = 0; channel < _num_outputs; ++channel) {
@@ -363,12 +356,11 @@ class audio_device final {
   static void sample_rate_changed(ASIOSampleRate) {}
 
   static long asio_message(long selector, long, void*, double*) {
-    switch (selector)
-    {
-    case kAsioSupportsTimeInfo: return ASIOTrue;
-    case kAsioEngineVersion: return 2;
-    case kAsioSelectorSupported: return ASIOFalse;
-    default: return ASIOFalse;
+    switch (selector) {
+      case kAsioSupportsTimeInfo: return ASIOTrue;
+      case kAsioEngineVersion: return 2;
+      case kAsioSelectorSupported: return ASIOFalse;
+      default: return ASIOFalse;
     }
   }
 
@@ -385,7 +377,7 @@ class audio_device final {
     _asio->outputReady();
   }
 
-  static ASIOTime* buffer_switch_time_info (ASIOTime* time, long index, ASIOBool) {
+  static ASIOTime* buffer_switch_time_info(ASIOTime* time, long index, ASIOBool) {
     return instance()->on_buffer_switch(time, index);
   }
 
@@ -437,11 +429,9 @@ class audio_device final {
   }
 };
 
-class audio_device_list : public forward_list<audio_device> {
-};
+class audio_device_list : public forward_list<audio_device> {};
 
-class __reg_key_reader final
-{
+class __reg_key_reader final {
 public:
   __reg_key_reader(HKEY key, const string& subkey) {
     RegOpenKeyExA(key, subkey.c_str(), 0, KEY_READ, &_key);
@@ -458,7 +448,7 @@ class __reg_key_reader final
     char name[max_asio_name_length];
     vector<string> keys;
 
-    for (DWORD index = 0; ; ++index) {
+    for (DWORD index = 0;; ++index) {
       DWORD size{max_asio_name_length};
       const auto result = RegEnumKeyEx(_key, index, name, &size, nullptr, nullptr, nullptr, nullptr);
 
@@ -576,10 +566,10 @@ class __asio_devices {
 
   static bool is_required(const audio_device& device, const audio_direction direction) {
     switch (direction) {
-    case audio_direction::in: return device.is_input();
-    case audio_direction::out: return device.is_output();
-    case audio_direction::full_duplex: return device.is_input() && device.is_output();
-    default: return false;
+      case audio_direction::in: return device.is_input();
+      case audio_direction::out: return device.is_output();
+      case audio_direction::full_duplex: return device.is_input() && device.is_output();
+      default: return false;
     };
   }
 
diff --git a/include/audio_backend/__asio_backend.h b/include/audio_backend/__asio_backend.h
index 80ca71d..6ea611f 100644
--- a/include/audio_backend/__asio_backend.h
+++ b/include/audio_backend/__asio_backend.h
@@ -29,7 +29,7 @@ audio_device_list get_audio_output_device_list() {
   return devices.outputs();
 }
 
-template <typename F, typename /* = enable_if_t<std::is_nothrow_invocable_v<F>> */ >
+template<typename F, typename /* = enable_if_t<std::is_nothrow_invocable_v<F>> */>
 void set_audio_device_list_callback(F&&) {
   // TODO: implement!
 }
diff --git a/include/audio_backend/__asio_sample.h b/include/audio_backend/__asio_sample.h
index 8908765..56960f4 100644
--- a/include/audio_backend/__asio_sample.h
+++ b/include/audio_backend/__asio_sample.h
@@ -10,33 +10,26 @@
 
 _LIBSTDAUDIO_NAMESPACE_BEGIN
 
-template <typename _SampleType>
-class __asio_sample
-{
+template<typename _SampleType>
+class __asio_sample {
 public:
   __asio_sample() = default;
-  explicit __asio_sample(_SampleType value)
-    : _value{ value }
-  {}
+  explicit __asio_sample(_SampleType value) : _value{value} {}
 
-  template <typename _IntegralType = _SampleType,
-            enable_if_t<is_integral<_IntegralType>::value, int> = 0>
+  template<typename _IntegralType = _SampleType, enable_if_t<is_integral<_IntegralType>::value, int> = 0>
   explicit __asio_sample(float value)
-    : __asio_sample(static_cast<_SampleType>(value * static_cast<double>(numeric_limits<_SampleType>::max())))
-  {}
+    : __asio_sample(static_cast<_SampleType>(value * static_cast<double>(numeric_limits<_SampleType>::max()))) {}
 
   int32_t int_value() const {
     return _value;
   }
 
-  template <typename _IntegralType = _SampleType,
-            enable_if_t<is_integral<_IntegralType>::value, int> = 0>
+  template<typename _IntegralType = _SampleType, enable_if_t<is_integral<_IntegralType>::value, int> = 0>
   float float_value() const {
     return static_cast<float>(_value) / numeric_limits<_SampleType>::max();
   }
 
-  template <typename _FloatType = _SampleType,
-            enable_if_t<is_floating_point<_FloatType>::value, int> = 0>
+  template<typename _FloatType = _SampleType, enable_if_t<is_floating_point<_FloatType>::value, int> = 0>
   float float_value() const {
     return static_cast<float>(_value);
   }
@@ -45,20 +38,15 @@ class __asio_sample
   _SampleType _value;
 };
 
-struct packed24_t{};
+struct packed24_t {};
 
-template <>
-class alignas(1) __asio_sample<packed24_t>
-{
+template<>
+class alignas(1) __asio_sample<packed24_t> {
 public:
   static constexpr int32_t _scale = 0x7f'ffff;
   __asio_sample() = default;
-  __asio_sample(int32_t value)
-    : data{ value & 0xff, (value >> 8) & 0xff, (value >> 16) & 0xff }
-  {}
-  __asio_sample(float value)
-    : __asio_sample{ static_cast<int32_t>(value * _scale) }
-  {}
+  __asio_sample(int32_t value) : data{value & 0xff, (value >> 8) & 0xff, (value >> 16) & 0xff} {}
+  __asio_sample(float value) : __asio_sample{static_cast<int32_t>(value * _scale)} {}
 
   int32_t int_value() const {
     return ((data[2] << 24) >> 8) | ((data[1] << 8) & 0xff00) | (data[0] & 0xff);

From 2e4ed65b389e2779aa77602243dacac8ed2a549d Mon Sep 17 00:00:00 2001
From: Andy Saul <andycsaul@gmail.com>
Date: Tue, 11 Jun 2019 22:04:12 +0100
Subject: [PATCH 77/97] Use template<class> consistently

As per Specification Style Guidelines
---
 .clang-format                               |  2 +-
 include/audio_backend/__asio_audio_device.h | 16 ++++++++--------
 include/audio_backend/__asio_backend.h      |  2 +-
 include/audio_backend/__asio_sample.h       |  8 ++++----
 4 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/.clang-format b/.clang-format
index a74792e..38ad09f 100644
--- a/.clang-format
+++ b/.clang-format
@@ -2,7 +2,7 @@
 
 BasedOnStyle: LLVM
 
-ColumnLimit: 100          # Arbitrary, feel free to adjust locally. 0 to ignore.
+ColumnLimit: 120          # Arbitrary, feel free to adjust locally. 0 to ignore.
 PenaltyExcessCharacter: 1 # Softest limit on line length.
 ReflowComments: false     # Best we don't do this without a consistent length limit.
 
diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 1950f9d..50da099 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -106,7 +106,7 @@ class audio_device final {
     return true;
   }
 
-  template<typename _SampleType>
+  template<class _SampleType>
   constexpr bool supports_sample_type() const noexcept {
     return is_same_v<_SampleType, __asio_common_sample_type>;
   }
@@ -122,10 +122,10 @@ class audio_device final {
   // TODO: remove std::function as soon as C++20 default-ctable lambda and lambda in unevaluated contexts become available
   using no_op_t = std::function<void(audio_device&)>;
 
-  template<typename _StartCallbackType = no_op_t,
-           typename _StopCallbackType = no_op_t,
+  template<class _StartCallbackType = no_op_t,
+           class _StopCallbackType = no_op_t,
            // TODO: is_nothrow_invocable_t does not compile, temporarily replaced with is_invocable_t
-           typename = enable_if_t<is_invocable_v<_StartCallbackType, audio_device&> && is_invocable_v<_StopCallbackType, audio_device&>>>
+           class = enable_if_t<is_invocable_v<_StartCallbackType, audio_device&> && is_invocable_v<_StopCallbackType, audio_device&>>>
   bool start(_StartCallbackType&& start_callback = [](audio_device&) noexcept {},
              _StopCallbackType&& stop_callback = [](audio_device&) noexcept {}) {
 
@@ -175,12 +175,12 @@ class audio_device final {
     assert(false);
   }
 
-  template<typename _CallbackType>
+  template<class _CallbackType>
   void process(_CallbackType&) {
     assert(false);
   }
 
-  template<typename _CallbackType, typename = enable_if_t<is_nothrow_invocable_v<_CallbackType, audio_device&, audio_device_io<float>&>>>
+  template<class _CallbackType, class = enable_if_t<is_nothrow_invocable_v<_CallbackType, audio_device&, audio_device_io<float>&>>>
   void connect(_CallbackType callback) {
     if (_running) {
       throw audio_device_exception("cannot connect to running audio_device");
@@ -311,7 +311,7 @@ class audio_device final {
     }
   }
 
-  template<typename _SampleType>
+  template<class _SampleType>
   void read(long index) {
 
     auto& in = *_io.input_buffer;
@@ -341,7 +341,7 @@ class audio_device final {
     }
   }
 
-  template<typename _SampleType>
+  template<class _SampleType>
   void write(long index) {
 
     auto& out = *_io.output_buffer;
diff --git a/include/audio_backend/__asio_backend.h b/include/audio_backend/__asio_backend.h
index 6ea611f..773b0da 100644
--- a/include/audio_backend/__asio_backend.h
+++ b/include/audio_backend/__asio_backend.h
@@ -29,7 +29,7 @@ audio_device_list get_audio_output_device_list() {
   return devices.outputs();
 }
 
-template<typename F, typename /* = enable_if_t<std::is_nothrow_invocable_v<F>> */>
+template<class F, class /* = enable_if_t<std::is_nothrow_invocable_v<F>> */>
 void set_audio_device_list_callback(F&&) {
   // TODO: implement!
 }
diff --git a/include/audio_backend/__asio_sample.h b/include/audio_backend/__asio_sample.h
index 56960f4..d9e228a 100644
--- a/include/audio_backend/__asio_sample.h
+++ b/include/audio_backend/__asio_sample.h
@@ -10,13 +10,13 @@
 
 _LIBSTDAUDIO_NAMESPACE_BEGIN
 
-template<typename _SampleType>
+template<class _SampleType>
 class __asio_sample {
 public:
   __asio_sample() = default;
   explicit __asio_sample(_SampleType value) : _value{value} {}
 
-  template<typename _IntegralType = _SampleType, enable_if_t<is_integral<_IntegralType>::value, int> = 0>
+  template<class _IntegralType = _SampleType, enable_if_t<is_integral<_IntegralType>::value, int> = 0>
   explicit __asio_sample(float value)
     : __asio_sample(static_cast<_SampleType>(value * static_cast<double>(numeric_limits<_SampleType>::max()))) {}
 
@@ -24,12 +24,12 @@ class __asio_sample {
     return _value;
   }
 
-  template<typename _IntegralType = _SampleType, enable_if_t<is_integral<_IntegralType>::value, int> = 0>
+  template<class _IntegralType = _SampleType, enable_if_t<is_integral<_IntegralType>::value, int> = 0>
   float float_value() const {
     return static_cast<float>(_value) / numeric_limits<_SampleType>::max();
   }
 
-  template<typename _FloatType = _SampleType, enable_if_t<is_floating_point<_FloatType>::value, int> = 0>
+  template<class _FloatType = _SampleType, enable_if_t<is_floating_point<_FloatType>::value, int> = 0>
   float float_value() const {
     return static_cast<float>(_value);
   }

From ceaf996d8e20b78352e64a9bb16e73c2ab5f3684 Mon Sep 17 00:00:00 2001
From: Andy Saul <andycsaul@gmail.com>
Date: Tue, 11 Jun 2019 22:08:41 +0100
Subject: [PATCH 78/97] Use braced initialisation for members consistently

---
 include/audio_backend/__asio_audio_device.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 50da099..d3b5b22 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -397,15 +397,15 @@ class audio_device final {
   CComPtr<IASIO> _asio;
   const string _name;
   device_id_t _id;
-  long _num_inputs = 0;
-  long _num_outputs = 0;
+  long _num_inputs{0};
+  long _num_outputs{0};
   vector<sample_rate_t> _sample_rates;
   vector<buffer_size_t> _buffer_sizes;
-  buffer_size_t _buffer_size = 0;
+  buffer_size_t _buffer_size{0};
   bool _running = false;
 
   ASIOSampleType _sample_type;
-  ASIOSamples _sample_position = 0;
+  ASIOSamples _sample_position{0};
 
   using __asio_callback_t = function<void(audio_device&, audio_device_io<float>&)>;
   __asio_callback_t _user_callback;

From 2c95cc6f5f8c1ee5c45d6fb3ed4da8438f3270b3 Mon Sep 17 00:00:00 2001
From: Andy Saul <andycsaul@gmail.com>
Date: Tue, 11 Jun 2019 22:15:04 +0100
Subject: [PATCH 79/97] Rename type

---
 include/audio_backend/__asio_audio_device.h | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index d3b5b22..d908a03 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -22,7 +22,7 @@
 
 _LIBSTDAUDIO_NAMESPACE_BEGIN
 
-using __asio_common_sample_type = float;
+using __asio_common_sample_t = float;
 
 struct audio_device_exception : public runtime_error {
   explicit audio_device_exception(const char* what) : runtime_error(what) {}
@@ -108,7 +108,7 @@ class audio_device final {
 
   template<class _SampleType>
   constexpr bool supports_sample_type() const noexcept {
-    return is_same_v<_SampleType, __asio_common_sample_type>;
+    return is_same_v<_SampleType, __asio_common_sample_t>;
   }
 
   constexpr bool can_connect() const noexcept {
@@ -407,11 +407,11 @@ class audio_device final {
   ASIOSampleType _sample_type;
   ASIOSamples _sample_position{0};
 
-  using __asio_callback_t = function<void(audio_device&, audio_device_io<float>&)>;
+  using __asio_callback_t = function<void(audio_device&, audio_device_io<__asio_common_sample_t>&)>;
   __asio_callback_t _user_callback;
-  audio_device_io<__asio_common_sample_type> _io;
-  vector<float> _input_samples;
-  vector<float> _output_samples;
+  audio_device_io<__asio_common_sample_t> _io;
+  vector<__asio_common_sample_t> _input_samples;
+  vector<__asio_common_sample_t> _output_samples;
 
   using fill_buffers = function<void(long index)>;
   fill_buffers _read;

From c337979f0cec0e8fb9bfb936d39384c9937aab9a Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sat, 15 Jun 2019 15:10:23 +0100
Subject: [PATCH 80/97] Apply clang-tidy fixes

---
 include/audio_backend/__asio_audio_device.h | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index d908a03..86b2517 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -35,7 +35,7 @@ class audio_device final {
   using device_id_t = int;
 
   explicit audio_device(device_id_t id, string name, IASIO* asio, audio_direction direction)
-    : _name(name), _id(id), _asio(asio) {
+    : _name(std::move(name)), _id(id), _asio(asio) {
     prepare_asio(direction);
   }
 
@@ -151,7 +151,6 @@ class audio_device final {
   }
 
   bool stop() {
-    //TODO: fade out to prevent audio clicks on stop
     const auto result = _asio->stop();
     _running = false;
     return result == ASE_OK;
@@ -215,6 +214,7 @@ class audio_device final {
     switch (direction) {
       case audio_direction::in: _num_outputs = 0; break;
       case audio_direction::out: _num_inputs = 0; break;
+      default: break;
     }
 
     long min;
@@ -281,7 +281,7 @@ class audio_device final {
     const auto result = _asio->createBuffers(_asio_buffers.data(), num_channels, _buffer_size, &_asio_callbacks);
 
     if (result != ASE_OK) {
-      throw audio_device_exception("failed to create ASIO buffers: " + result);
+      throw audio_device_exception("failed to create ASIO buffers");
     }
 
     _input_samples.resize(_num_inputs * _buffer_size);
@@ -307,7 +307,7 @@ class audio_device final {
       case ASIOSTFloat32LSB: _read = [this](long index) { read<float>(index); }; break;
       case ASIOSTFloat64LSB: _read = [this](long index) { read<double>(index); }; break;
 
-      default: throw audio_device_exception("ASIO native sample type not supported: " + _sample_type);
+      default: throw audio_device_exception("ASIO native sample type not supported");
     }
   }
 
@@ -337,7 +337,7 @@ class audio_device final {
       case ASIOSTFloat32LSB: _write = [this](long index) { write<float>(index); }; break;
       case ASIOSTFloat64LSB: _write = [this](long index) { write<double>(index); }; break;
 
-      default: throw audio_device_exception("ASIO native sample type not supported: " + _sample_type);
+      default: throw audio_device_exception("ASIO native sample type not supported");
     }
   }
 
@@ -404,7 +404,7 @@ class audio_device final {
   buffer_size_t _buffer_size{0};
   bool _running = false;
 
-  ASIOSampleType _sample_type;
+  ASIOSampleType _sample_type{};
   ASIOSamples _sample_position{0};
 
   using __asio_callback_t = function<void(audio_device&, audio_device_io<__asio_common_sample_t>&)>;
@@ -418,7 +418,7 @@ class audio_device final {
   fill_buffers _write;
 
   vector<ASIOBufferInfo> _asio_buffers;
-  ASIOCallbacks _asio_callbacks;
+  ASIOCallbacks _asio_callbacks{};
 
   static audio_device* instance(optional<audio_device*> new_device = {}) {
     static audio_device* device = nullptr;
@@ -477,7 +477,7 @@ class __reg_key_reader final {
   }
 
 private:
-  HKEY _key{0};
+  HKEY _key{nullptr};
 };
 
 class __asio_devices {
@@ -549,7 +549,7 @@ class __asio_devices {
     CComPtr<IASIO> asio;
     const auto result = CoCreateInstance(class_id, nullptr, CLSCTX_INPROC_SERVER, class_id, reinterpret_cast<void**>(&asio));
     if (result) {
-      throw audio_device_exception("Failed to open ASIO driver: 0x" + result);
+      throw audio_device_exception("Failed to open ASIO driver");
     }
 
     if (!is_connected(asio)) {
@@ -570,7 +570,7 @@ class __asio_devices {
       case audio_direction::out: return device.is_output();
       case audio_direction::full_duplex: return device.is_input() && device.is_output();
       default: return false;
-    };
+    }
   }
 
   static bool is_excluded(string_view name) {

From 9f59a9c33bdd3e903a265ca02a4085d2fec6472f Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sat, 15 Jun 2019 15:47:49 +0100
Subject: [PATCH 81/97] Apply clang-tidy fixes

---
 test/asio_test.cpp | 67 +++++++++++++++++++---------------------------
 1 file changed, 28 insertions(+), 39 deletions(-)

diff --git a/test/asio_test.cpp b/test/asio_test.cpp
index 28406ae..e611d3f 100644
--- a/test/asio_test.cpp
+++ b/test/asio_test.cpp
@@ -58,7 +58,7 @@ TEST_CASE("Converts integer samples to floating point samples", "[asio]")
 
   SECTION("Converts from 24-bit samples")
   {
-    CHECK(__asio_sample<packed24_t>(0).float_value() == 0.f);;
+    CHECK(__asio_sample<packed24_t>(0).float_value() == 0.f);
     CHECK(__asio_sample<packed24_t>(0x7f'ffff).float_value() == 1.f);
     CHECK(__asio_sample<packed24_t>(-0x7f'ffff).float_value() == -1.f);
 
@@ -93,9 +93,9 @@ TEST_CASE("Converts integer samples to floating point samples", "[asio]")
 class mock_asio : public trompeloeil::mock_interface<IASIO>
 {
 public:
-  MAKE_MOCK2(QueryInterface, long(const IID&, void**), override);
-  IMPLEMENT_MOCK0(AddRef);
-  IMPLEMENT_MOCK0(Release);
+  long __stdcall QueryInterface(const IID&, void**) override {return 0;}
+  unsigned long __stdcall AddRef() {return 1;}
+  unsigned long __stdcall Release() {return 0;}
   IMPLEMENT_MOCK1(init);
   IMPLEMENT_MOCK1(getDriverName);
   IMPLEMENT_MOCK0(getDriverVersion);
@@ -129,8 +129,6 @@ class asio_device_builder
 
   audio_device_ptr operator()()
   {
-    REQUIRE_CALL(asio, AddRef()).RETURN(1);
-
     REQUIRE_CALL(asio, getChannels(_, _))
       .SIDE_EFFECT(*_1 = num_inputs)
       .SIDE_EFFECT(*_2 = num_outputs)
@@ -159,7 +157,6 @@ class asio_device_builder
 
     return {new audio_device(id, name, &asio, direction), [&](auto* device) {
       REQUIRE_CALL(asio, stop()).RETURN(ASIOTrue);
-      REQUIRE_CALL(asio, Release()).RETURN(0);
       ALLOW_CALL(asio, disposeBuffers()).RETURN(0);
       delete device;
     }};
@@ -490,25 +487,23 @@ TEST_CASE_METHOD(asio_device_fixture, "Device cannot be started before connectio
 
 TEST_CASE_METHOD(asio_device_fixture, "Device writes outputs from legacy callbacks", "[asio]")
 {
-  constexpr long num_channels{2};
-  constexpr long num_frames{32};
   auto device = make_asio_device
-    .with_num_output_channels(num_channels)
-    .with_unique_buffer_size(num_frames)();
+    .with_num_output_channels(2)
+    .with_unique_buffer_size(32)();
 
   connect(*device, [&](audio_device& d, audio_device_io<float>& io) mutable noexcept {
     CHECK(device.get() == &d);
     auto& out = *io.output_buffer;
     CHECK(io.output_buffer.has_value());
-    CHECK(out.size_channels() == num_channels);
-    CHECK(out.size_frames() == num_frames);
-    for (int frame = 0; frame < out.size_frames(); ++frame) {
+    CHECK(out.size_channels() == 2);
+    CHECK(out.size_frames() == 32);
+    for (size_t frame = 0; frame < out.size_frames(); ++frame) {
       out(frame, 0) = 1.0f;
       out(frame, 1) = -1.0f;
     }
   });
 
-  allocate_buffers(num_channels, num_frames);
+  allocate_buffers(2, 32);
 
   REQUIRE_CALL(asio, start()).RETURN(0);
   REQUIRE_CALL(asio, outputReady()).RETURN(0);
@@ -522,25 +517,23 @@ TEST_CASE_METHOD(asio_device_fixture, "Device writes outputs from legacy callbac
 
 TEST_CASE_METHOD(asio_device_fixture, "Device writes outputs from timestamped callbacks", "[asio]")
 {
-  constexpr long num_channels{2};
-  constexpr long num_frames{32};
   auto device = make_asio_device
-    .with_num_output_channels(num_channels)
-    .with_unique_buffer_size(num_frames)();
+    .with_num_output_channels(2)
+    .with_unique_buffer_size(32)();
 
   connect(*device, [&](audio_device& d, audio_device_io<float>& io) mutable noexcept {
     CHECK(device.get() == &d);
     auto& out = *io.output_buffer;
     CHECK(io.output_buffer.has_value());
-    CHECK(out.size_channels() == num_channels);
-    CHECK(out.size_frames() == num_frames);
-    for (int frame = 0; frame < out.size_frames(); ++frame) {
+    CHECK(out.size_channels() == 2);
+    CHECK(out.size_frames() == 32);
+    for (size_t frame = 0; frame < out.size_frames(); ++frame) {
       out(frame, 0) = 1.0f;
       out(frame, 1) = -1.0f;
     }
   });
 
-  allocate_buffers(num_channels, num_frames);
+  allocate_buffers(2, 32);
 
   REQUIRE_CALL(asio, start()).RETURN(0);
   CHECK(device->start());
@@ -550,7 +543,7 @@ TEST_CASE_METHOD(asio_device_fixture, "Device writes outputs from timestamped ca
   CHECK(result->timeInfo.samplePosition == 0);
 
   result = callbacks->bufferSwitchTimeInfo(&time, 0, ASIOFalse);
-  CHECK(result->timeInfo.samplePosition == num_frames);
+  CHECK(result->timeInfo.samplePosition == 32);
 
   verify_out_value(0, 0x7fff'ffff);
   verify_out_value(1, -0x7fff'ffff);
@@ -582,23 +575,21 @@ TEST_CASE_METHOD(asio_device_fixture, "Throws exception if connection attempted
 
 TEST_CASE_METHOD(asio_device_fixture, "Device reads inputs from legacy callbacks", "[asio]")
 {
-  constexpr long num_channels{2};
-  constexpr long num_frames{32};
   auto device = make_asio_device
-    .with_num_input_channels(num_channels)
-    .with_unique_buffer_size(num_frames)();
+    .with_num_input_channels(2)
+    .with_unique_buffer_size(32)();
 
   connect(*device, [&](audio_device& d, audio_device_io<float>& io) mutable noexcept {
     CHECK(device.get() == &d);
     auto& in = *io.input_buffer;
     CHECK(io.input_buffer.has_value());
-    CHECK(in.size_channels() == num_channels);
-    CHECK(in.size_frames() == num_frames);
+    CHECK(in.size_channels() == 2);
+    CHECK(in.size_frames() == 32);
     CHECK(in(0, 0) == 1.f);
     CHECK(in(0, 1) == -1.0f);
   });
 
-  allocate_buffers(num_channels, num_frames);
+  allocate_buffers(2, 32);
   set_input_value(0, 0x7fff'ffff);
   set_input_value(1, -0x7fff'ffff);
 
@@ -611,23 +602,21 @@ TEST_CASE_METHOD(asio_device_fixture, "Device reads inputs from legacy callbacks
 
 TEST_CASE_METHOD(asio_device_fixture, "Device reads inputs from timestamped callbacks", "[asio]")
 {
-  constexpr long num_channels{2};
-  constexpr long num_frames{32};
   auto device = make_asio_device
-    .with_num_input_channels(num_channels)
-    .with_unique_buffer_size(num_frames)();
+    .with_num_input_channels(2)
+    .with_unique_buffer_size(32)();
 
   connect(*device, [&](audio_device& d, audio_device_io<float>& io) mutable noexcept {
     CHECK(device.get() == &d);
     auto& in = *io.input_buffer;
     CHECK(io.input_buffer.has_value());
-    CHECK(in.size_channels() == num_channels);
-    CHECK(in.size_frames() == num_frames);
+    CHECK(in.size_channels() == 2);
+    CHECK(in.size_frames() == 32);
     CHECK(in(0, 0) == 1.f);
     CHECK(in(0, 1) == -1.0f);
   });
 
-  allocate_buffers(num_channels, num_frames);
+  allocate_buffers(2, 32);
   set_input_value(0, 0x7fff'ffff);
   set_input_value(1, -0x7fff'ffff);
 
@@ -638,5 +627,5 @@ TEST_CASE_METHOD(asio_device_fixture, "Device reads inputs from timestamped call
   auto result = callbacks->bufferSwitchTimeInfo(&time, 0, ASIOFalse);
   CHECK(result->timeInfo.samplePosition == 0);
   result = callbacks->bufferSwitchTimeInfo(&time, 0, ASIOFalse);
-  CHECK(result->timeInfo.samplePosition == num_frames);
+  CHECK(result->timeInfo.samplePosition == 32);
 }

From 0e383415d00462044b893f23a1455de7579128c7 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sat, 15 Jun 2019 16:34:15 +0100
Subject: [PATCH 82/97] Use size_t for loop iteration

---
 examples/melody.cpp                         | 6 +++---
 examples/sine_wave.cpp                      | 4 ++--
 examples/white_noise.cpp                    | 4 ++--
 include/__audio_buffer.h                    | 4 ++--
 include/audio_backend/__asio_audio_device.h | 4 ++--
 5 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/examples/melody.cpp b/examples/melody.cpp
index 68fbf2d..70cf61a 100644
--- a/examples/melody.cpp
+++ b/examples/melody.cpp
@@ -68,7 +68,7 @@ struct synthesiser {
   float _phase = 0;
   float _ms_counter = 0;
   float _note_duration_ms = 60'000.0f / bpm;
-  int _current_note_index = 0;
+  size_t _current_note_index = 0;
 };
 
 
@@ -88,10 +88,10 @@ int main() {
 
     auto& out = *io.output_buffer;
 
-    for (int frame = 0; frame < out.size_frames(); ++frame) {
+    for (size_t frame = 0; frame < out.size_frames(); ++frame) {
       auto next_sample = synth.get_next_sample();
 
-      for (int channel = 0; channel < out.size_channels(); ++channel)
+      for (size_t channel = 0; channel < out.size_channels(); ++channel)
         out(frame, channel) = next_sample;
     }
   });
diff --git a/examples/sine_wave.cpp b/examples/sine_wave.cpp
index 1789d40..5360532 100644
--- a/examples/sine_wave.cpp
+++ b/examples/sine_wave.cpp
@@ -30,11 +30,11 @@ int main() {
 
     auto& out = *io.output_buffer;
 
-    for (int frame = 0; frame < out.size_frames(); ++frame) {
+    for (size_t frame = 0; frame < out.size_frames(); ++frame) {
       const float next_sample = std::sin(phase);
       phase = std::fmod(phase + delta, 2.0f * static_cast<float>(M_PI));
 
-      for (int channel = 0; channel < out.size_channels(); ++channel)
+      for (size_t channel = 0; channel < out.size_channels(); ++channel)
         out(frame, channel) = 0.2f * next_sample;
     }
   });
diff --git a/examples/white_noise.cpp b/examples/white_noise.cpp
index a6d21ce..a587a8a 100644
--- a/examples/white_noise.cpp
+++ b/examples/white_noise.cpp
@@ -23,8 +23,8 @@ int main() {
 
       auto &out = *io.output_buffer;
 
-      for (int frame = 0; frame < out.size_frames(); ++frame)
-        for (int channel = 0; channel < out.size_channels(); ++channel)
+      for (size_t frame = 0; frame < out.size_frames(); ++frame)
+        for (size_t channel = 0; channel < out.size_channels(); ++channel)
           out(frame, channel) = white_noise(gen);
     });
 
diff --git a/include/__audio_buffer.h b/include/__audio_buffer.h
index 5083cec..ddf12e1 100644
--- a/include/__audio_buffer.h
+++ b/include/__audio_buffer.h
@@ -32,7 +32,7 @@ class audio_buffer {
       _stride(_num_channels),
       _is_contiguous(true) {
     assert (num_channels <= _max_num_channels);
-    for (auto i = 0; i < _num_channels; ++i) {
+    for (index_type i = 0; i < _num_channels; ++i) {
       _channels[i] = data + i;
     }
   }
@@ -43,7 +43,7 @@ class audio_buffer {
         _stride(1),
         _is_contiguous(true) {
     assert (num_channels <= _max_num_channels);
-    for (auto i = 0; i < _num_channels; ++i) {
+    for (index_type i = 0; i < _num_channels; ++i) {
       _channels[i] = data + (i * _num_frames);
     }
   }
diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 86b2517..d89f69b 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -317,7 +317,7 @@ class audio_device final {
     auto& in = *_io.input_buffer;
     for (int channel = 0; channel < _num_inputs; ++channel) {
       const auto buffer = static_cast<__asio_sample<_SampleType>*>(_asio_buffers[channel].buffers[index]);
-      for (int frame = 0; frame < in.size_frames(); ++frame) {
+      for (size_t frame = 0; frame < in.size_frames(); ++frame) {
         in(frame, channel) = buffer[frame].float_value();
       }
     }
@@ -347,7 +347,7 @@ class audio_device final {
     auto& out = *_io.output_buffer;
     for (int channel = 0; channel < _num_outputs; ++channel) {
       const auto buffer = static_cast<__asio_sample<_SampleType>*>(_asio_buffers[_num_inputs + channel].buffers[index]);
-      for (int frame = 0; frame < out.size_frames(); ++frame) {
+      for (size_t frame = 0; frame < out.size_frames(); ++frame) {
         buffer[frame] = {out(frame, channel)};
       }
     }

From 253cc44ef035129149a7a1fd05b1ace0a218c0df Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sat, 15 Jun 2019 19:19:01 +0100
Subject: [PATCH 83/97] Don't expose Windows max macro to audio clients

---
 include/audio_backend/__asio_audio_device.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index d89f69b..a2c98b2 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -7,6 +7,7 @@
 
 #include "__asio_sample.h"
 
+#define NOMINMAX
 #include "iasiodrv.h"
 
 #include <cassert>
@@ -17,6 +18,7 @@
 #include <vector>
 
 #define WIN32_LEAN_AND_MEAN
+#define NOMINMAX
 #include <Windows.h>
 #include <atlbase.h>
 

From 3c38016558a084c4ff3e5c82c381cbcf8997f25d Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sat, 15 Jun 2019 19:35:45 +0100
Subject: [PATCH 84/97] Add null implementation of
 set_audio_device_list_callback

---
 include/audio_backend/__asio_backend.h | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/include/audio_backend/__asio_backend.h b/include/audio_backend/__asio_backend.h
index 773b0da..36dbcea 100644
--- a/include/audio_backend/__asio_backend.h
+++ b/include/audio_backend/__asio_backend.h
@@ -29,9 +29,11 @@ audio_device_list get_audio_output_device_list() {
   return devices.outputs();
 }
 
-template<class F, class /* = enable_if_t<std::is_nothrow_invocable_v<F>> */>
-void set_audio_device_list_callback(F&&) {
-  // TODO: implement!
+template <typename F, typename /* = enable_if_t<is_nothrow_invocable_v<F>> */ >
+void set_audio_device_list_callback(audio_device_list_event, F&& cb) {
+  // TODO: Implement this.
+  // For now, swallow the callback function to keep the compiler happy
+  function <void()>(move(cb));
 }
 
 _LIBSTDAUDIO_NAMESPACE_END

From c08eeb3481ef4d7f017f133cf1968bd0e0622520 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sat, 15 Jun 2019 20:16:25 +0100
Subject: [PATCH 85/97] Use size_t for loop iteration

---
 examples/level_meter.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/level_meter.cpp b/examples/level_meter.cpp
index 22d1180..07c2409 100644
--- a/examples/level_meter.cpp
+++ b/examples/level_meter.cpp
@@ -30,8 +30,8 @@ int main() {
 
     auto& in = *io.input_buffer;
 
-    for (int frame = 0; frame < in.size_frames(); ++frame) {
-      for (int channel = 0; channel < in.size_channels(); ++channel) {
+    for (size_t frame = 0; frame < in.size_frames(); ++frame) {
+      for (size_t channel = 0; channel < in.size_channels(); ++channel) {
         const float abs_value = std::abs(in(frame, channel));
 
         if (abs_value > max_abs_value)

From 95784298168a8d8f68226d9c5bb8583e30488402 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sat, 15 Jun 2019 20:17:00 +0100
Subject: [PATCH 86/97] Remove empty statement

---
 examples/print_devices.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/print_devices.cpp b/examples/print_devices.cpp
index f41aff6..b4a5ac4 100644
--- a/examples/print_devices.cpp
+++ b/examples/print_devices.cpp
@@ -28,7 +28,7 @@ void print_device_info(const audio_device& d) {
   std::cout << "buffer size = " << d.get_buffer_size_frames() << " frames, ";
   std::cout << (d.is_input() ? d.get_num_input_channels() : d.get_num_output_channels()) << " channels";
   std::cout << (is_default_device(d) ? " [DEFAULT DEVICE]\n" : "\n");
-};
+}
 
 void print_device_list(const audio_device_list& list) {
   for (auto& item : list) {

From 24cf0e1b7898d6556e0a2ad214b9a43a6c8ff83a Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sat, 15 Jun 2019 20:47:08 +0100
Subject: [PATCH 87/97] Remove functions that have been removed from API

---
 include/audio_backend/__asio_audio_device.h |  8 ----
 test/asio_test.cpp                          | 44 ++++-----------------
 2 files changed, 7 insertions(+), 45 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index a2c98b2..e0ecb95 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -81,10 +81,6 @@ class audio_device final {
     return sample_rate;
   }
 
-  span<const sample_rate_t> get_supported_sample_rates() const noexcept {
-    return _sample_rates;
-  }
-
   bool set_sample_rate(sample_rate_t sample_rate) {
     const auto result = _asio->setSampleRate(sample_rate);
     return result == ASE_OK;
@@ -96,10 +92,6 @@ class audio_device final {
     return _buffer_size;
   }
 
-  span<const buffer_size_t> get_supported_buffer_sizes_frames() const noexcept {
-    return _buffer_sizes;
-  }
-
   bool set_buffer_size_frames(const buffer_size_t buffer_size) {
     if (find(begin(_buffer_sizes), end(_buffer_sizes), buffer_size) == end(_buffer_sizes)) {
       return false;
diff --git a/test/asio_test.cpp b/test/asio_test.cpp
index e611d3f..231bea9 100644
--- a/test/asio_test.cpp
+++ b/test/asio_test.cpp
@@ -376,10 +376,7 @@ TEST_CASE_METHOD(asio_device_fixture, "Supports unique buffer size", "[asio]")
 {
   auto device = make_asio_device.with_unique_buffer_size(1024)();
 
-  auto buffer_sizes = device->get_supported_buffer_sizes_frames();
-
-  CHECK(buffer_sizes.size() == 1);
-  CHECK(buffer_sizes[0] == 1024);
+  // TODO: Use future API to query for allowed buffer sizes
   CHECK(device->get_buffer_size_frames() == 1024);
   CHECK(device->set_buffer_size_frames(1024));
   CHECK_FALSE(device->set_buffer_size_frames(64));
@@ -387,17 +384,14 @@ TEST_CASE_METHOD(asio_device_fixture, "Supports unique buffer size", "[asio]")
 
 TEST_CASE_METHOD(asio_device_fixture, "Supports power-of-two buffer sizes", "[asio]")
 {
-  const std::array<buffer_size_t, 5> expected_buffer_sizes{64, 128, 256, 512, 1024};
-
   auto device = make_asio_device
     .with_power_of_two_buffer_sizes(64, 1024)
     .with_preferred_buffer_size(256)();
 
-  const auto buffer_sizes = device->get_supported_buffer_sizes_frames();
-  CHECK(buffer_sizes == span<const buffer_size_t>(expected_buffer_sizes));
+  // TODO: Use future API to query for allowed buffer sizes
   CHECK(device->get_buffer_size_frames() == 256);
 
-  for (const auto size : expected_buffer_sizes) {
+  for (const auto size : {64, 128, 256, 512, 1024}) {
     CHECK(device->set_buffer_size_frames(size));
     CHECK_FALSE(device->set_buffer_size_frames(size + 1));
     CHECK_FALSE(device->set_buffer_size_frames(size - 1));
@@ -407,17 +401,14 @@ TEST_CASE_METHOD(asio_device_fixture, "Supports power-of-two buffer sizes", "[as
 
 TEST_CASE_METHOD(asio_device_fixture, "Supports buffer size ranges", "[asio]")
 {
-  const std::array<buffer_size_t, 4> expected_buffer_sizes{64, 128, 192, 256};
-
   auto device = make_asio_device
     .with_buffer_size_range(64, 256, 64)
     .with_preferred_buffer_size(192)();
 
-  const auto buffer_sizes = device->get_supported_buffer_sizes_frames();
-  CHECK(buffer_sizes == span<const buffer_size_t>(expected_buffer_sizes));
+  // TODO: Use future API to query for allowed buffer sizes
   CHECK(device->get_buffer_size_frames() == 192);
 
-  for (const auto size : expected_buffer_sizes) {
+  for (const auto size : {64, 128, 192, 256}) {
     CHECK(device->set_buffer_size_frames(size));
     CHECK_FALSE(device->set_buffer_size_frames(size + 1));
     CHECK_FALSE(device->set_buffer_size_frames(size - 1));
@@ -427,36 +418,15 @@ TEST_CASE_METHOD(asio_device_fixture, "Supports buffer size ranges", "[asio]")
 
 TEST_CASE_METHOD(asio_device_fixture, "Supports common samplerates", "[asio]")
 {
-  const std::array<sample_rate_t, 6>
-    expected_sample_rates{44'100, 48'000, 88'200, 96'000, 176'400, 192'000};
-
   auto device = make_asio_device();
 
-  const auto sample_rates = device->get_supported_sample_rates();
-  CHECK(sample_rates == span<const sample_rate_t>(expected_sample_rates));
-
-  for (const auto rate : expected_sample_rates) {
+  // TODO: Use future API to query for allowed sample rates
+  for (const auto rate : {44'100, 48'000, 88'200, 96'000, 176'400, 192'000}) {
     ALLOW_CALL(asio, setSampleRate(_)).RETURN(make_asio_device.is_supported_sample_rate(rate));
     CHECK(device->set_sample_rate(rate));
   }
 }
 
-TEST_CASE_METHOD(asio_device_fixture, "Supports subset of common samplerates", "[asio]")
-{
-  const std::vector<sample_rate_t> expected_sample_rates{44'100, 48'000};
-
-  auto device = make_asio_device.with_sample_rates(expected_sample_rates)();
-
-  const auto sample_rates = device->get_supported_sample_rates();
-  CHECK(sample_rates == span<const sample_rate_t>(expected_sample_rates));
-
-  const std::array<sample_rate_t, 4> banned_sample_rates{88'200, 96'000, 176'400, 192'000};
-  for (const auto rate : banned_sample_rates) {
-    ALLOW_CALL(asio, setSampleRate(_)).RETURN(make_asio_device.is_supported_sample_rate(rate));
-    CHECK_FALSE(device->set_sample_rate(rate));
-  }
-}
-
 TEST_CASE_METHOD(asio_device_fixture, "Can connect to device", "[asio]")
 {
   auto device = make_asio_device();

From 59b2d15508474cdd753446709ad9d04f9686e039 Mon Sep 17 00:00:00 2001
From: Andy Saul <andy.saul@displaylink.com>
Date: Sat, 15 Jun 2019 20:50:09 +0100
Subject: [PATCH 88/97] Remove span, it is no longer used in the project

---
 include/audio | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/include/audio b/include/audio
index 1a86347..2fa467b 100644
--- a/include/audio
+++ b/include/audio
@@ -7,11 +7,6 @@
 
 #include <optional>
 
-// TODO: this is a temporary measure until std::span becomes available
-#include "cpp/span.hpp"
-template<class ElementType, std::ptrdiff_t Extent = TCB_SPAN_NAMESPACE_NAME::dynamic_extent>
-using span = TCB_SPAN_NAMESPACE_NAME::span<ElementType, Extent>;
-
 #define _LIBSTDAUDIO_NAMESPACE std::experimental
 
 #define _LIBSTDAUDIO_NAMESPACE_BEGIN namespace _LIBSTDAUDIO_NAMESPACE {

From 2ed7e68ce648b1f70134fe8b7c7934e3ae5ec6a4 Mon Sep 17 00:00:00 2001
From: Andy Saul <no_reply>
Date: Sun, 16 Jun 2019 14:23:59 +0100
Subject: [PATCH 89/97] Remove unnecessary temporary

---
 include/audio_backend/__asio_audio_device.h | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index e0ecb95..9c0c845 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -250,9 +250,7 @@ class audio_device final {
   }
 
   void query_sample_rates() {
-    constexpr array<sample_rate_t, 6> common_sample_rates = {44'100, 48'000, 88'200, 96'000, 176'400, 192'000};
-
-    for (const auto sample_rate : common_sample_rates) {
+    for (const auto sample_rate : {44'100, 48'000, 88'200, 96'000, 176'400, 192'000}) {
       if (ASE_OK == _asio->canSampleRate(sample_rate)) {
         _sample_rates.push_back(sample_rate);
       }
@@ -545,11 +543,9 @@ class __asio_devices {
     if (result) {
       throw audio_device_exception("Failed to open ASIO driver");
     }
-
     if (!is_connected(asio)) {
       return {};
     }
-
     const auto device = audio_device(_index++, name, asio, direction);
     if (!is_required(device, direction)) {
       return {};

From 1fa4a457146c134c6b0e969c9be4e722f7acec1c Mon Sep 17 00:00:00 2001
From: Andy Saul <no_reply>
Date: Sun, 16 Jun 2019 15:08:00 +0100
Subject: [PATCH 90/97] Suppress clang-format warnings

---
 include/audio_backend/__asio_audio_device.h |  4 ++--
 test/asio_test.cpp                          | 16 ++++++++--------
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 9c0c845..99c5c2d 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -379,7 +379,7 @@ class audio_device final {
     _user_callback(*this, _io);
     _write(index);
 
-    time->timeInfo.flags = kSystemTimeValid | kSamplePositionValid;
+    time->timeInfo.flags = kSystemTimeValid | kSamplePositionValid; // NOLINT(hicpp-signed-bitwise)
     time->timeInfo.samplePosition = _sample_position;
     _sample_position += _buffer_size;
     time->timeInfo.systemTime = timeGetTime() * 1'000'000;
@@ -426,7 +426,7 @@ class audio_device_list : public forward_list<audio_device> {};
 class __reg_key_reader final {
 public:
   __reg_key_reader(HKEY key, const string& subkey) {
-    RegOpenKeyExA(key, subkey.c_str(), 0, KEY_READ, &_key);
+    RegOpenKeyExA(key, subkey.c_str(), 0, KEY_READ, &_key); // NOLINT(hicpp-signed-bitwise)
   }
 
   ~__reg_key_reader() {
diff --git a/test/asio_test.cpp b/test/asio_test.cpp
index 231bea9..bff66e3 100644
--- a/test/asio_test.cpp
+++ b/test/asio_test.cpp
@@ -94,8 +94,8 @@ class mock_asio : public trompeloeil::mock_interface<IASIO>
 {
 public:
   long __stdcall QueryInterface(const IID&, void**) override {return 0;}
-  unsigned long __stdcall AddRef() {return 1;}
-  unsigned long __stdcall Release() {return 0;}
+  unsigned long __stdcall AddRef() override {return 1;}
+  unsigned long __stdcall Release() override {return 0;}
   IMPLEMENT_MOCK1(init);
   IMPLEMENT_MOCK1(getDriverName);
   IMPLEMENT_MOCK0(getDriverVersion);
@@ -122,7 +122,7 @@ class mock_asio : public trompeloeil::mock_interface<IASIO>
 class asio_device_builder
 {
 public:
-  asio_device_builder(mock_asio& asio) : asio(asio)
+  explicit asio_device_builder(mock_asio& asio) : asio(asio)
   {}
 
   using audio_device_ptr = std::unique_ptr<audio_device, std::function<void(audio_device*)>>;
@@ -224,7 +224,7 @@ class asio_device_builder
   }
 
   asio_device_builder& with_sample_rates(std::vector<sample_rate_t> new_sample_rates) {
-    sample_rates = new_sample_rates;
+    sample_rates = std::move(new_sample_rates);
     return *this;
   }
 
@@ -267,11 +267,11 @@ class asio_device_fixture
 
   void allocate_buffers(const uint32_t num_channels, const uint32_t num_frames) {
     buffer.resize(2 * num_channels * num_frames);
-    auto p = buffer.data();
+    auto data = buffer.data();
     for (uint32_t c = 0; c < num_channels; ++c) {
-      for (uint32_t i = 0; i < 2; ++i) {
-        asio_buffers[c].buffers[i] = p;
-        p += num_frames;
+      for (auto & asio_buffer : asio_buffers[c].buffers) {
+        asio_buffer = data;
+        data += num_frames;
       }
     }
   }

From 6d044cf25443be58a88a3657a44edbd23946c838 Mon Sep 17 00:00:00 2001
From: Andy Saul <no_reply>
Date: Sun, 16 Jun 2019 15:48:19 +0100
Subject: [PATCH 91/97] Delete methods removed from specification

---
 include/audio_backend/__asio_audio_device.h | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 99c5c2d..dc7991e 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -158,16 +158,6 @@ class audio_device final {
     assert(false);
   }
 
-  template<class _Rep, class _Period>
-  void wait_for(chrono::duration<_Rep, _Period> rel_time) const {
-    assert(false);
-  }
-
-  template<class _Clock, class _Duration>
-  void wait_until(chrono::time_point<_Clock, _Duration> abs_time) const {
-    assert(false);
-  }
-
   template<class _CallbackType>
   void process(_CallbackType&) {
     assert(false);

From 82fe582e1688f47ff4ed9ddbc0a5d66dda477cbe Mon Sep 17 00:00:00 2001
From: Andy Saul <no_reply>
Date: Sun, 16 Jun 2019 17:10:08 +0100
Subject: [PATCH 92/97] Fix clang-tidy warnings

---
 include/audio_backend/__asio_audio_device.h |  2 +-
 include/audio_backend/__asio_sample.h       | 10 +++++++---
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index dc7991e..e5614bf 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -330,7 +330,7 @@ class audio_device final {
     for (int channel = 0; channel < _num_outputs; ++channel) {
       const auto buffer = static_cast<__asio_sample<_SampleType>*>(_asio_buffers[_num_inputs + channel].buffers[index]);
       for (size_t frame = 0; frame < out.size_frames(); ++frame) {
-        buffer[frame] = {out(frame, channel)};
+        buffer[frame] = __asio_sample<_SampleType>(out(frame, channel));
       }
     }
   }
diff --git a/include/audio_backend/__asio_sample.h b/include/audio_backend/__asio_sample.h
index d9e228a..761c1d9 100644
--- a/include/audio_backend/__asio_sample.h
+++ b/include/audio_backend/__asio_sample.h
@@ -45,11 +45,15 @@ class alignas(1) __asio_sample<packed24_t> {
 public:
   static constexpr int32_t _scale = 0x7f'ffff;
   __asio_sample() = default;
-  __asio_sample(int32_t value) : data{value & 0xff, (value >> 8) & 0xff, (value >> 16) & 0xff} {}
-  __asio_sample(float value) : __asio_sample{static_cast<int32_t>(value * _scale)} {}
+  explicit __asio_sample(const int32_t value)
+    : data{static_cast<int8_t>(value & 0xff),         // NOLINT(hicpp-signed-bitwise)
+           static_cast<int8_t>((value >> 8) & 0xff),  // NOLINT(hicpp-signed-bitwise)
+           static_cast<int8_t>((value >> 16) & 0xff)} // NOLINT(hicpp-signed-bitwise)
+  {}
+  explicit __asio_sample(const float value) : __asio_sample{static_cast<int32_t>(value * _scale)} {}
 
   int32_t int_value() const {
-    return ((data[2] << 24) >> 8) | ((data[1] << 8) & 0xff00) | (data[0] & 0xff);
+    return ((data[2] << 24) >> 8) | ((data[1] << 8) & 0xff00) | (data[0] & 0xff); // NOLINT(hicpp-signed-bitwise)
   }
 
   float float_value() const {

From 6551018123328cc4a0f2673a4c751f8098ea9b20 Mon Sep 17 00:00:00 2001
From: Andy Saul <no_reply>
Date: Sun, 16 Jun 2019 17:31:57 +0100
Subject: [PATCH 93/97] Reformat

---
 include/audio_backend/__asio_audio_device.h |  36 +---
 include/audio_backend/__asio_backend.h      |   6 +-
 test/asio_test.cpp                          | 213 +++++++-------------
 3 files changed, 83 insertions(+), 172 deletions(-)

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index e5614bf..e8a1e35 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -18,7 +18,6 @@
 #include <vector>
 
 #define WIN32_LEAN_AND_MEAN
-#define NOMINMAX
 #include <Windows.h>
 #include <atlbase.h>
 
@@ -169,13 +168,11 @@ class audio_device final {
       throw audio_device_exception("cannot connect to running audio_device");
     }
     _user_callback = move(callback);
-
     allocate_buffers();
   }
 
 private:
   void prepare_asio(const audio_direction direction) {
-
     set_callbacks();
     query_io(direction);
     query_sample_rates();
@@ -190,32 +187,26 @@ class audio_device final {
 
   void query_io(const audio_direction direction) {
     auto result = _asio->getChannels(&_num_inputs, &_num_outputs);
-
     if (result != ASE_OK) {
       return;
     }
-
     switch (direction) {
       case audio_direction::in: _num_outputs = 0; break;
       case audio_direction::out: _num_inputs = 0; break;
       default: break;
     }
-
     long min;
     long max;
     long granularity;
     result = _asio->getBufferSize(&min, &max, &_buffer_size, &granularity);
-
     if (result != ASE_OK) {
       return;
     }
-
     switch (granularity) {
       default: set_buffers(min, max, granularity); break;
       case -1: set_buffers_as_powers_of_two(min, max); break;
       case 0: set_buffers_as_default_size_only(); break;
     }
-
     set_buffer_size_frames(_buffer_size);
 
     ASIOChannelInfo info{0, is_input()};
@@ -251,7 +242,6 @@ class audio_device final {
   }
 
   void allocate_buffers() {
-
     for (int i = 0; i < _num_inputs; ++i) {
       _asio_buffers.emplace_back(ASIOBufferInfo{true, i});
     }
@@ -325,12 +315,12 @@ class audio_device final {
 
   template<class _SampleType>
   void write(long index) {
-
+    using sample = __asio_sample<_SampleType>;
     auto& out = *_io.output_buffer;
     for (int channel = 0; channel < _num_outputs; ++channel) {
-      const auto buffer = static_cast<__asio_sample<_SampleType>*>(_asio_buffers[_num_inputs + channel].buffers[index]);
+      const auto buffer = static_cast<sample*>(_asio_buffers[_num_inputs + channel].buffers[index]);
       for (size_t frame = 0; frame < out.size_frames(); ++frame) {
-        buffer[frame] = __asio_sample<_SampleType>(out(frame, channel));
+        buffer[frame] = sample(out(frame, channel));
       }
     }
   }
@@ -351,7 +341,6 @@ class audio_device final {
   }
 
   void on_buffer_switch(long index) {
-
     _read(index);
     _user_callback(*this, _io);
     _write(index);
@@ -364,7 +353,6 @@ class audio_device final {
   }
 
   ASIOTime* on_buffer_switch(ASIOTime* time, long index) {
-
     _read(index);
     _user_callback(*this, _io);
     _write(index);
@@ -413,13 +401,13 @@ class audio_device final {
 
 class audio_device_list : public forward_list<audio_device> {};
 
-class __reg_key_reader final {
+class __reg_key final {
 public:
-  __reg_key_reader(HKEY key, const string& subkey) {
+  __reg_key(HKEY key, const string& subkey) {
     RegOpenKeyExA(key, subkey.c_str(), 0, KEY_READ, &_key); // NOLINT(hicpp-signed-bitwise)
   }
 
-  ~__reg_key_reader() {
+  ~__reg_key() {
     if (_key) {
       RegCloseKey(_key);
     }
@@ -433,25 +421,21 @@ class __reg_key_reader final {
     for (DWORD index = 0;; ++index) {
       DWORD size{max_asio_name_length};
       const auto result = RegEnumKeyEx(_key, index, name, &size, nullptr, nullptr, nullptr, nullptr);
-
       if (result != ERROR_SUCCESS) {
         break;
       }
-
       keys.emplace_back(name);
     }
-
     return keys;
   }
 
-  __reg_key_reader subkey(const string& name) const {
+  __reg_key subkey(const string& name) const {
     return {_key, name};
   }
 
   string value(const char* name) const {
     DWORD size{0};
     RegQueryValueExA(_key, name, nullptr, nullptr, nullptr, &size);
-
     string value(size + 1, 0);
     RegQueryValueExA(_key, name, nullptr, nullptr, reinterpret_cast<LPBYTE>(value.data()), &size);
 
@@ -507,9 +491,7 @@ class __asio_devices {
     _index = 0;
 
     for (const auto& name : _asio_reg.subkeys()) {
-
       auto device = open_device(name, direction);
-
       if (device) {
         devices.push_front(move(*device));
       }
@@ -518,7 +500,6 @@ class __asio_devices {
   }
 
   optional<audio_device> open_device(const string& name, const audio_direction direction) const {
-
     if (is_excluded(name)) {
       return {};
     }
@@ -540,7 +521,6 @@ class __asio_devices {
     if (!is_required(device, direction)) {
       return {};
     }
-
     return device;
   }
 
@@ -567,7 +547,7 @@ class __asio_devices {
     return ASIOTrue == asio->init(nullptr);
   }
 
-  __reg_key_reader _asio_reg{HKEY_LOCAL_MACHINE, R"(software\asio)"};
+  __reg_key _asio_reg{HKEY_LOCAL_MACHINE, R"(software\asio)"};
   mutable int _index{0};
 };
 
diff --git a/include/audio_backend/__asio_backend.h b/include/audio_backend/__asio_backend.h
index 36dbcea..681392a 100644
--- a/include/audio_backend/__asio_backend.h
+++ b/include/audio_backend/__asio_backend.h
@@ -29,11 +29,9 @@ audio_device_list get_audio_output_device_list() {
   return devices.outputs();
 }
 
-template <typename F, typename /* = enable_if_t<is_nothrow_invocable_v<F>> */ >
-void set_audio_device_list_callback(audio_device_list_event, F&& cb) {
+template<class F, class /* = enable_if_t<is_nothrow_invocable_v<F>> */>
+void set_audio_device_list_callback(audio_device_list_event, F&&) {
   // TODO: Implement this.
-  // For now, swallow the callback function to keep the compiler happy
-  function <void()>(move(cb));
 }
 
 _LIBSTDAUDIO_NAMESPACE_END
diff --git a/test/asio_test.cpp b/test/asio_test.cpp
index bff66e3..706e8a0 100644
--- a/test/asio_test.cpp
+++ b/test/asio_test.cpp
@@ -3,10 +3,10 @@
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
 
-#include <audio>
 #include "catch/catch.hpp"
 #include "catch/trompeloeil.hpp"
 #include "trompeloeil.hpp"
+#include <audio>
 
 using namespace std::experimental;
 
@@ -15,10 +15,8 @@ using trompeloeil::_;
 using sample_rate_t = audio_device::sample_rate_t;
 using buffer_size_t = audio_device::buffer_size_t;
 
-TEST_CASE("Converts floating point samples to integer samples", "[asio]")
-{
-  SECTION("Converts to 32-bit samples")
-  {
+TEST_CASE("Converts floating point samples to integer samples", "[asio]") {
+  SECTION("Converts to 32-bit samples") {
     CHECK(__asio_sample<int32_t>(0.f).int_value() == 0);
     CHECK(__asio_sample<int32_t>(1.f).int_value() == 0x7fff'ffff);
     CHECK(__asio_sample<int32_t>(-1.f).int_value() == -0x7fff'ffff);
@@ -26,8 +24,7 @@ TEST_CASE("Converts floating point samples to integer samples", "[asio]")
     CHECK(__asio_sample<int32_t>(-0.5f).int_value() == -0x7fff'ffff / 2);
   }
 
-  SECTION("Converts to 24-bit samples")
-  {
+  SECTION("Converts to 24-bit samples") {
     CHECK(__asio_sample<packed24_t>(0.f).int_value() == 0);
     CHECK(__asio_sample<packed24_t>(1.f).int_value() == 0x7f'ffff);
     CHECK(__asio_sample<packed24_t>(-1.f).int_value() == -0x7f'ffff);
@@ -35,8 +32,7 @@ TEST_CASE("Converts floating point samples to integer samples", "[asio]")
     CHECK(__asio_sample<packed24_t>(-0.5f).int_value() == -0x7f'ffff / 2);
   }
 
-  SECTION("Converts to 16-bit samples")
-  {
+  SECTION("Converts to 16-bit samples") {
     CHECK(__asio_sample<int16_t>(0.f).int_value() == 0);
     CHECK(__asio_sample<int16_t>(1.f).int_value() == 0x7fff);
     CHECK(__asio_sample<int16_t>(-1.f).int_value() == -0x7fff);
@@ -45,10 +41,8 @@ TEST_CASE("Converts floating point samples to integer samples", "[asio]")
   }
 }
 
-TEST_CASE("Converts integer samples to floating point samples", "[asio]")
-{
-  SECTION("Converts from 32-bit samples")
-  {
+TEST_CASE("Converts integer samples to floating point samples", "[asio]") {
+  SECTION("Converts from 32-bit samples") {
     CHECK(__asio_sample<int32_t>(0).float_value() == 0.f);
     CHECK(__asio_sample<int32_t>(0x7fff'ffff).float_value() == 1.f);
     CHECK(__asio_sample<int32_t>(-0x7fff'ffff).float_value() == -1.f);
@@ -56,8 +50,7 @@ TEST_CASE("Converts integer samples to floating point samples", "[asio]")
     CHECK(__asio_sample<int32_t>(-0x7fff'ffff / 2).float_value() == -0.5f);
   }
 
-  SECTION("Converts from 24-bit samples")
-  {
+  SECTION("Converts from 24-bit samples") {
     CHECK(__asio_sample<packed24_t>(0).float_value() == 0.f);
     CHECK(__asio_sample<packed24_t>(0x7f'ffff).float_value() == 1.f);
     CHECK(__asio_sample<packed24_t>(-0x7f'ffff).float_value() == -1.f);
@@ -69,8 +62,7 @@ TEST_CASE("Converts integer samples to floating point samples", "[asio]")
     CHECK(Approx(minus_half) == -0.5f);
   }
 
-  SECTION("Converts from 16-bit samples")
-  {
+  SECTION("Converts from 16-bit samples") {
     int16_t value = 0;
     CHECK(__asio_sample<int16_t>(value).float_value() == 0.f);
 
@@ -90,12 +82,17 @@ TEST_CASE("Converts integer samples to floating point samples", "[asio]")
   }
 }
 
-class mock_asio : public trompeloeil::mock_interface<IASIO>
-{
+class mock_asio : public trompeloeil::mock_interface<IASIO> {
 public:
-  long __stdcall QueryInterface(const IID&, void**) override {return 0;}
-  unsigned long __stdcall AddRef() override {return 1;}
-  unsigned long __stdcall Release() override {return 0;}
+  long __stdcall QueryInterface(const IID&, void**) override {
+    return 0;
+  }
+  unsigned long __stdcall AddRef() override {
+    return 1;
+  }
+  unsigned long __stdcall Release() override {
+    return 0;
+  }
   IMPLEMENT_MOCK1(init);
   IMPLEMENT_MOCK1(getDriverName);
   IMPLEMENT_MOCK0(getDriverVersion);
@@ -119,20 +116,14 @@ class mock_asio : public trompeloeil::mock_interface<IASIO>
   IMPLEMENT_MOCK0(outputReady);
 };
 
-class asio_device_builder
-{
+class asio_device_builder {
 public:
-  explicit asio_device_builder(mock_asio& asio) : asio(asio)
-  {}
+  explicit asio_device_builder(mock_asio& asio) : asio(asio) {}
 
   using audio_device_ptr = std::unique_ptr<audio_device, std::function<void(audio_device*)>>;
 
-  audio_device_ptr operator()()
-  {
-    REQUIRE_CALL(asio, getChannels(_, _))
-      .SIDE_EFFECT(*_1 = num_inputs)
-      .SIDE_EFFECT(*_2 = num_outputs)
-      .RETURN(0);
+  audio_device_ptr operator()() {
+    REQUIRE_CALL(asio, getChannels(_, _)).SIDE_EFFECT(*_1 = num_inputs).SIDE_EFFECT(*_2 = num_outputs).RETURN(0);
 
     REQUIRE_CALL(asio, getBufferSize(_, _, _, _))
       .SIDE_EFFECT(*_1 = min_buffer_size)
@@ -141,31 +132,22 @@ class asio_device_builder
       .SIDE_EFFECT(*_4 = granularity)
       .RETURN(0);
 
-    REQUIRE_CALL(asio, getChannelInfo(_))
-      .SIDE_EFFECT(*_1 = info)
-      .RETURN(0);
+    REQUIRE_CALL(asio, getChannelInfo(_)).SIDE_EFFECT(*_1 = info).RETURN(0);
 
-    REQUIRE_CALL(asio, canSampleRate(_))
-      .TIMES(6)
-      .RETURN(is_supported_sample_rate(_1));
+    REQUIRE_CALL(asio, canSampleRate(_)).TIMES(6).RETURN(is_supported_sample_rate(_1));
 
-    constexpr double sample_rate{ 44'100.0 };
-    REQUIRE_CALL(asio, getSampleRate(_))
-      .SIDE_EFFECT(*_1 = sample_rate)
-      .TIMES(AT_LEAST(1))
-      .RETURN(ASIOTrue);
+    constexpr double sample_rate{44'100.0};
+    REQUIRE_CALL(asio, getSampleRate(_)).SIDE_EFFECT(*_1 = sample_rate).TIMES(AT_LEAST(1)).RETURN(ASIOTrue);
 
     return {new audio_device(id, name, &asio, direction), [&](auto* device) {
-      REQUIRE_CALL(asio, stop()).RETURN(ASIOTrue);
-      ALLOW_CALL(asio, disposeBuffers()).RETURN(0);
-      delete device;
-    }};
+              REQUIRE_CALL(asio, stop()).RETURN(ASIOTrue);
+              ALLOW_CALL(asio, disposeBuffers()).RETURN(0);
+              delete device;
+            }};
   }
 
   long is_supported_sample_rate(const sample_rate_t rate) const {
-    return std::find(sample_rates.begin(), sample_rates.end(), rate) == sample_rates.end()
-      ? ASE_NotPresent
-      : ASE_OK;
+    return std::find(sample_rates.begin(), sample_rates.end(), rate) == sample_rates.end() ? ASE_NotPresent : ASE_OK;
   }
 
   asio_device_builder& with_id(const audio_device::device_id_t new_id) {
@@ -246,8 +228,7 @@ class asio_device_builder
   std::vector<sample_rate_t> sample_rates{44'100, 48'000, 88'200, 96'000, 176'400, 192'000};
 };
 
-class asio_device_fixture
-{
+class asio_device_fixture {
 public:
   mock_asio asio;
   asio_device_builder make_asio_device{asio};
@@ -256,12 +237,9 @@ class asio_device_fixture
   ASIOBufferInfo* asio_buffers;
   std::vector<int32_t> buffer;
 
-  template <typename _CallbackType>
+  template<typename _CallbackType>
   void connect(audio_device& device, _CallbackType callback) {
-    REQUIRE_CALL(asio, createBuffers(_, _, _, _))
-      .LR_SIDE_EFFECT(asio_buffers = _1)
-      .LR_SIDE_EFFECT(callbacks = _4)
-      .RETURN(0);
+    REQUIRE_CALL(asio, createBuffers(_, _, _, _)).LR_SIDE_EFFECT(asio_buffers = _1).LR_SIDE_EFFECT(callbacks = _4).RETURN(0);
     device.connect(callback);
   }
 
@@ -269,7 +247,7 @@ class asio_device_fixture
     buffer.resize(2 * num_channels * num_frames);
     auto data = buffer.data();
     for (uint32_t c = 0; c < num_channels; ++c) {
-      for (auto & asio_buffer : asio_buffers[c].buffers) {
+      for (auto& asio_buffer : asio_buffers[c].buffers) {
         asio_buffer = data;
         data += num_frames;
       }
@@ -288,57 +266,48 @@ class asio_device_fixture
   }
 };
 
-TEST_CASE_METHOD(asio_device_fixture, "Creates device with id", "[asio]")
-{
+TEST_CASE_METHOD(asio_device_fixture, "Creates device with id", "[asio]") {
   auto device = make_asio_device.with_id(42)();
 
   CHECK(device->device_id() == 42);
 }
 
-TEST_CASE_METHOD(asio_device_fixture, "Creates device with name", "[asio]")
-{
+TEST_CASE_METHOD(asio_device_fixture, "Creates device with name", "[asio]") {
   auto device = make_asio_device.with_name("Fake ASIO")();
 
   CHECK(device->name() == "Fake ASIO");
 }
 
-TEST_CASE_METHOD(asio_device_fixture, "Creates stereo output device", "[asio]")
-{
+TEST_CASE_METHOD(asio_device_fixture, "Creates stereo output device", "[asio]") {
   auto device = make_asio_device.with_num_output_channels(2)();
 
   CHECK(device->is_output());
   CHECK(device->get_num_output_channels() == 2);
 }
 
-TEST_CASE_METHOD(asio_device_fixture, "Creates mono output device", "[asio]")
-{
+TEST_CASE_METHOD(asio_device_fixture, "Creates mono output device", "[asio]") {
   auto device = make_asio_device.with_num_output_channels(1)();
 
   CHECK(device->is_output());
   CHECK(device->get_num_output_channels() == 1);
 }
 
-TEST_CASE_METHOD(asio_device_fixture, "Creates stereo input device", "[asio]")
-{
+TEST_CASE_METHOD(asio_device_fixture, "Creates stereo input device", "[asio]") {
   auto device = make_asio_device.with_num_input_channels(2)();
 
   CHECK(device->is_input());
   CHECK(device->get_num_input_channels() == 2);
 }
 
-TEST_CASE_METHOD(asio_device_fixture, "Creates mono input device", "[asio]")
-{
+TEST_CASE_METHOD(asio_device_fixture, "Creates mono input device", "[asio]") {
   auto device = make_asio_device.with_num_input_channels(1)();
 
   CHECK(device->is_input());
   CHECK(device->get_num_input_channels() == 1);
 }
 
-TEST_CASE_METHOD(asio_device_fixture, "Creates full duplex device", "[asio]")
-{
-  auto device = make_asio_device
-    .with_num_input_channels(4)
-    .with_num_output_channels(4)();
+TEST_CASE_METHOD(asio_device_fixture, "Creates full duplex device", "[asio]") {
+  auto device = make_asio_device.with_num_input_channels(4).with_num_output_channels(4)();
 
   CHECK(device->is_input());
   CHECK(device->get_num_input_channels() == 4);
@@ -346,12 +315,8 @@ TEST_CASE_METHOD(asio_device_fixture, "Creates full duplex device", "[asio]")
   CHECK(device->get_num_output_channels() == 4);
 }
 
-TEST_CASE_METHOD(asio_device_fixture, "Creates input-only device from duplex ASIO", "[asio]")
-{
-  auto device = make_asio_device
-    .with_num_input_channels(4)
-    .with_num_output_channels(4)
-    .using_inputs_only()();
+TEST_CASE_METHOD(asio_device_fixture, "Creates input-only device from duplex ASIO", "[asio]") {
+  auto device = make_asio_device.with_num_input_channels(4).with_num_output_channels(4).using_inputs_only()();
 
   CHECK(device->is_input());
   CHECK(device->get_num_input_channels() == 4);
@@ -359,12 +324,8 @@ TEST_CASE_METHOD(asio_device_fixture, "Creates input-only device from duplex ASI
   CHECK(device->get_num_output_channels() == 0);
 }
 
-TEST_CASE_METHOD(asio_device_fixture, "Creates output-only device from duplex ASIO", "[asio]")
-{
-  auto device = make_asio_device
-    .with_num_input_channels(4)
-    .with_num_output_channels(4)
-    .using_outputs_only()();
+TEST_CASE_METHOD(asio_device_fixture, "Creates output-only device from duplex ASIO", "[asio]") {
+  auto device = make_asio_device.with_num_input_channels(4).with_num_output_channels(4).using_outputs_only()();
 
   CHECK_FALSE(device->is_input());
   CHECK(device->get_num_input_channels() == 0);
@@ -372,8 +333,7 @@ TEST_CASE_METHOD(asio_device_fixture, "Creates output-only device from duplex AS
   CHECK(device->get_num_output_channels() == 4);
 }
 
-TEST_CASE_METHOD(asio_device_fixture, "Supports unique buffer size", "[asio]")
-{
+TEST_CASE_METHOD(asio_device_fixture, "Supports unique buffer size", "[asio]") {
   auto device = make_asio_device.with_unique_buffer_size(1024)();
 
   // TODO: Use future API to query for allowed buffer sizes
@@ -382,11 +342,8 @@ TEST_CASE_METHOD(asio_device_fixture, "Supports unique buffer size", "[asio]")
   CHECK_FALSE(device->set_buffer_size_frames(64));
 }
 
-TEST_CASE_METHOD(asio_device_fixture, "Supports power-of-two buffer sizes", "[asio]")
-{
-  auto device = make_asio_device
-    .with_power_of_two_buffer_sizes(64, 1024)
-    .with_preferred_buffer_size(256)();
+TEST_CASE_METHOD(asio_device_fixture, "Supports power-of-two buffer sizes", "[asio]") {
+  auto device = make_asio_device.with_power_of_two_buffer_sizes(64, 1024).with_preferred_buffer_size(256)();
 
   // TODO: Use future API to query for allowed buffer sizes
   CHECK(device->get_buffer_size_frames() == 256);
@@ -399,11 +356,8 @@ TEST_CASE_METHOD(asio_device_fixture, "Supports power-of-two buffer sizes", "[as
   }
 }
 
-TEST_CASE_METHOD(asio_device_fixture, "Supports buffer size ranges", "[asio]")
-{
-  auto device = make_asio_device
-    .with_buffer_size_range(64, 256, 64)
-    .with_preferred_buffer_size(192)();
+TEST_CASE_METHOD(asio_device_fixture, "Supports buffer size ranges", "[asio]") {
+  auto device = make_asio_device.with_buffer_size_range(64, 256, 64).with_preferred_buffer_size(192)();
 
   // TODO: Use future API to query for allowed buffer sizes
   CHECK(device->get_buffer_size_frames() == 192);
@@ -416,8 +370,7 @@ TEST_CASE_METHOD(asio_device_fixture, "Supports buffer size ranges", "[asio]")
   }
 }
 
-TEST_CASE_METHOD(asio_device_fixture, "Supports common samplerates", "[asio]")
-{
+TEST_CASE_METHOD(asio_device_fixture, "Supports common samplerates", "[asio]") {
   auto device = make_asio_device();
 
   // TODO: Use future API to query for allowed sample rates
@@ -427,41 +380,34 @@ TEST_CASE_METHOD(asio_device_fixture, "Supports common samplerates", "[asio]")
   }
 }
 
-TEST_CASE_METHOD(asio_device_fixture, "Can connect to device", "[asio]")
-{
+TEST_CASE_METHOD(asio_device_fixture, "Can connect to device", "[asio]") {
   auto device = make_asio_device();
 
   CHECK(device->can_connect());
 }
 
-TEST_CASE_METHOD(asio_device_fixture, "Cannot poll device", "[asio]")
-{
+TEST_CASE_METHOD(asio_device_fixture, "Cannot poll device", "[asio]") {
   auto device = make_asio_device();
 
   CHECK_FALSE(device->can_process());
 }
 
-TEST_CASE_METHOD(asio_device_fixture, "Device is not running before connection", "[asio]")
-{
+TEST_CASE_METHOD(asio_device_fixture, "Device is not running before connection", "[asio]") {
   auto device = make_asio_device();
 
   CHECK_FALSE(device->is_running());
 }
 
-TEST_CASE_METHOD(asio_device_fixture, "Device cannot be started before connection", "[asio]")
-{
+TEST_CASE_METHOD(asio_device_fixture, "Device cannot be started before connection", "[asio]") {
   auto device = make_asio_device();
 
   CHECK_FALSE(device->start());
 }
 
-TEST_CASE_METHOD(asio_device_fixture, "Device writes outputs from legacy callbacks", "[asio]")
-{
-  auto device = make_asio_device
-    .with_num_output_channels(2)
-    .with_unique_buffer_size(32)();
+TEST_CASE_METHOD(asio_device_fixture, "Device writes outputs from legacy callbacks", "[asio]") {
+  auto device = make_asio_device.with_num_output_channels(2).with_unique_buffer_size(32)();
 
-  connect(*device, [&](audio_device& d, audio_device_io<float>& io) mutable noexcept {
+  connect(*device, [&](audio_device & d, audio_device_io<float> & io) mutable noexcept {
     CHECK(device.get() == &d);
     auto& out = *io.output_buffer;
     CHECK(io.output_buffer.has_value());
@@ -485,13 +431,10 @@ TEST_CASE_METHOD(asio_device_fixture, "Device writes outputs from legacy callbac
   verify_out_value(1, -0x7fff'ffff);
 }
 
-TEST_CASE_METHOD(asio_device_fixture, "Device writes outputs from timestamped callbacks", "[asio]")
-{
-  auto device = make_asio_device
-    .with_num_output_channels(2)
-    .with_unique_buffer_size(32)();
+TEST_CASE_METHOD(asio_device_fixture, "Device writes outputs from timestamped callbacks", "[asio]") {
+  auto device = make_asio_device.with_num_output_channels(2).with_unique_buffer_size(32)();
 
-  connect(*device, [&](audio_device& d, audio_device_io<float>& io) mutable noexcept {
+  connect(*device, [&](audio_device & d, audio_device_io<float> & io) mutable noexcept {
     CHECK(device.get() == &d);
     auto& out = *io.output_buffer;
     CHECK(io.output_buffer.has_value());
@@ -519,8 +462,7 @@ TEST_CASE_METHOD(asio_device_fixture, "Device writes outputs from timestamped ca
   verify_out_value(1, -0x7fff'ffff);
 }
 
-TEST_CASE_METHOD(asio_device_fixture, "Device responds to ASIO message callback", "[asio]")
-{
+TEST_CASE_METHOD(asio_device_fixture, "Device responds to ASIO message callback", "[asio]") {
   const auto device = make_asio_device();
   connect(*device, [](auto&, auto&) noexcept {});
 
@@ -529,11 +471,8 @@ TEST_CASE_METHOD(asio_device_fixture, "Device responds to ASIO message callback"
   CHECK(callbacks->asioMessage(kAsioSelectorSupported, 0, nullptr, nullptr) == ASIOFalse);
 }
 
-TEST_CASE_METHOD(asio_device_fixture, "Throws exception if connection attempted when already running", "[asio]")
-{
-  const auto device = make_asio_device
-    .with_num_output_channels(1)
-    .with_unique_buffer_size(1)();
+TEST_CASE_METHOD(asio_device_fixture, "Throws exception if connection attempted when already running", "[asio]") {
+  const auto device = make_asio_device.with_num_output_channels(1).with_unique_buffer_size(1)();
   const auto no_op = [](auto&, auto&) noexcept {};
   connect(*device, no_op);
   REQUIRE_CALL(asio, start()).RETURN(0);
@@ -543,13 +482,10 @@ TEST_CASE_METHOD(asio_device_fixture, "Throws exception if connection attempted
   CHECK_THROWS_AS(device->connect(no_op), audio_device_exception);
 }
 
-TEST_CASE_METHOD(asio_device_fixture, "Device reads inputs from legacy callbacks", "[asio]")
-{
-  auto device = make_asio_device
-    .with_num_input_channels(2)
-    .with_unique_buffer_size(32)();
+TEST_CASE_METHOD(asio_device_fixture, "Device reads inputs from legacy callbacks", "[asio]") {
+  auto device = make_asio_device.with_num_input_channels(2).with_unique_buffer_size(32)();
 
-  connect(*device, [&](audio_device& d, audio_device_io<float>& io) mutable noexcept {
+  connect(*device, [&](audio_device & d, audio_device_io<float> & io) mutable noexcept {
     CHECK(device.get() == &d);
     auto& in = *io.input_buffer;
     CHECK(io.input_buffer.has_value());
@@ -570,13 +506,10 @@ TEST_CASE_METHOD(asio_device_fixture, "Device reads inputs from legacy callbacks
   callbacks->bufferSwitch(0, ASIOFalse);
 }
 
-TEST_CASE_METHOD(asio_device_fixture, "Device reads inputs from timestamped callbacks", "[asio]")
-{
-  auto device = make_asio_device
-    .with_num_input_channels(2)
-    .with_unique_buffer_size(32)();
+TEST_CASE_METHOD(asio_device_fixture, "Device reads inputs from timestamped callbacks", "[asio]") {
+  auto device = make_asio_device.with_num_input_channels(2).with_unique_buffer_size(32)();
 
-  connect(*device, [&](audio_device& d, audio_device_io<float>& io) mutable noexcept {
+  connect(*device, [&](audio_device & d, audio_device_io<float> & io) mutable noexcept {
     CHECK(device.get() == &d);
     auto& in = *io.input_buffer;
     CHECK(io.input_buffer.has_value());

From c842ce1aad38458ac7832ac7551a2ce634138328 Mon Sep 17 00:00:00 2001
From: AndySaul <no_reply>
Date: Sun, 16 Jun 2019 18:12:14 +0100
Subject: [PATCH 94/97] Push __asio_sample class into common header

---
 include/audio_backend/__asio_audio_device.h | 58 +++++++++++++++++-
 include/audio_backend/__asio_sample.h       | 67 ---------------------
 2 files changed, 56 insertions(+), 69 deletions(-)
 delete mode 100644 include/audio_backend/__asio_sample.h

diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index e8a1e35..022ea78 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -5,15 +5,15 @@
 
 #pragma once
 
-#include "__asio_sample.h"
-
 #define NOMINMAX
 #include "iasiodrv.h"
 
+#include <array>
 #include <cassert>
 #include <chrono>
 #include <forward_list>
 #include <functional>
+#include <numeric>
 #include <string_view>
 #include <vector>
 
@@ -29,6 +29,60 @@ struct audio_device_exception : public runtime_error {
   explicit audio_device_exception(const char* what) : runtime_error(what) {}
 };
 
+template<class _SampleType>
+class __asio_sample {
+public:
+  __asio_sample() = default;
+  explicit __asio_sample(_SampleType value) : _value{value} {}
+
+  template<class _IntegralType = _SampleType, enable_if_t<is_integral<_IntegralType>::value, int> = 0>
+  explicit __asio_sample(float value)
+    : __asio_sample(static_cast<_SampleType>(value * static_cast<double>(numeric_limits<_SampleType>::max()))) {}
+
+  int32_t int_value() const {
+    return _value;
+  }
+
+  template<class _IntegralType = _SampleType, enable_if_t<is_integral<_IntegralType>::value, int> = 0>
+  float float_value() const {
+    return static_cast<float>(_value) / numeric_limits<_SampleType>::max();
+  }
+
+  template<class _FloatType = _SampleType, enable_if_t<is_floating_point<_FloatType>::value, int> = 0>
+  float float_value() const {
+    return static_cast<float>(_value);
+  }
+
+private:
+  _SampleType _value;
+};
+
+struct packed24_t {};
+
+template<>
+class alignas(1) __asio_sample<packed24_t> {
+public:
+  static constexpr int32_t _scale = 0x7f'ffff;
+  __asio_sample() = default;
+  explicit __asio_sample(const int32_t value)
+    : data{static_cast<int8_t>(value & 0xff),         // NOLINT(hicpp-signed-bitwise)
+           static_cast<int8_t>((value >> 8) & 0xff),  // NOLINT(hicpp-signed-bitwise)
+           static_cast<int8_t>((value >> 16) & 0xff)} // NOLINT(hicpp-signed-bitwise)
+  {}
+  explicit __asio_sample(const float value) : __asio_sample{static_cast<int32_t>(value * _scale)} {}
+
+  int32_t int_value() const {
+    return ((data[2] << 24) >> 8) | ((data[1] << 8) & 0xff00) | (data[0] & 0xff); // NOLINT(hicpp-signed-bitwise)
+  }
+
+  float float_value() const {
+    return static_cast<float>(int_value()) / _scale;
+  }
+
+private:
+  array<int8_t, 3> data;
+};
+
 enum class audio_direction { in, out, full_duplex };
 
 class audio_device final {
diff --git a/include/audio_backend/__asio_sample.h b/include/audio_backend/__asio_sample.h
deleted file mode 100644
index 761c1d9..0000000
--- a/include/audio_backend/__asio_sample.h
+++ /dev/null
@@ -1,67 +0,0 @@
-// libstdaudio
-// Copyright (c) 2019 Andy Saul
-// 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 <array>
-#include <numeric>
-
-_LIBSTDAUDIO_NAMESPACE_BEGIN
-
-template<class _SampleType>
-class __asio_sample {
-public:
-  __asio_sample() = default;
-  explicit __asio_sample(_SampleType value) : _value{value} {}
-
-  template<class _IntegralType = _SampleType, enable_if_t<is_integral<_IntegralType>::value, int> = 0>
-  explicit __asio_sample(float value)
-    : __asio_sample(static_cast<_SampleType>(value * static_cast<double>(numeric_limits<_SampleType>::max()))) {}
-
-  int32_t int_value() const {
-    return _value;
-  }
-
-  template<class _IntegralType = _SampleType, enable_if_t<is_integral<_IntegralType>::value, int> = 0>
-  float float_value() const {
-    return static_cast<float>(_value) / numeric_limits<_SampleType>::max();
-  }
-
-  template<class _FloatType = _SampleType, enable_if_t<is_floating_point<_FloatType>::value, int> = 0>
-  float float_value() const {
-    return static_cast<float>(_value);
-  }
-
-private:
-  _SampleType _value;
-};
-
-struct packed24_t {};
-
-template<>
-class alignas(1) __asio_sample<packed24_t> {
-public:
-  static constexpr int32_t _scale = 0x7f'ffff;
-  __asio_sample() = default;
-  explicit __asio_sample(const int32_t value)
-    : data{static_cast<int8_t>(value & 0xff),         // NOLINT(hicpp-signed-bitwise)
-           static_cast<int8_t>((value >> 8) & 0xff),  // NOLINT(hicpp-signed-bitwise)
-           static_cast<int8_t>((value >> 16) & 0xff)} // NOLINT(hicpp-signed-bitwise)
-  {}
-  explicit __asio_sample(const float value) : __asio_sample{static_cast<int32_t>(value * _scale)} {}
-
-  int32_t int_value() const {
-    return ((data[2] << 24) >> 8) | ((data[1] << 8) & 0xff00) | (data[0] & 0xff); // NOLINT(hicpp-signed-bitwise)
-  }
-
-  float float_value() const {
-    return static_cast<float>(int_value()) / _scale;
-  }
-
-private:
-  array<int8_t, 3> data;
-};
-
-_LIBSTDAUDIO_NAMESPACE_END

From d0d171b51fe156e3a196d3ab2733c4ece1a90cbd Mon Sep 17 00:00:00 2001
From: AndySaul <no_reply>
Date: Sun, 16 Jun 2019 18:25:49 +0100
Subject: [PATCH 95/97] Push main functions into common header

---
 include/audio                               |  2 +-
 include/audio_backend/__asio_audio_device.h | 25 ++++++++++++++
 include/audio_backend/__asio_backend.h      | 37 ---------------------
 3 files changed, 26 insertions(+), 38 deletions(-)
 delete mode 100644 include/audio_backend/__asio_backend.h

diff --git a/include/audio b/include/audio
index 2fa467b..35f07df 100644
--- a/include/audio
+++ b/include/audio
@@ -18,7 +18,7 @@
 #ifdef __APPLE__
   #include <audio_backend/__coreaudio_backend.h>
 #elif defined _WIN32
-  #include <audio_backend/__asio_backend.h>
+  #include <audio_backend/__asio_audio_device.h>
 #else
   #include <audio_backend/__null_backend.h>
 #endif // __APPLE__
diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_audio_device.h
index 022ea78..fe00b29 100644
--- a/include/audio_backend/__asio_audio_device.h
+++ b/include/audio_backend/__asio_audio_device.h
@@ -605,4 +605,29 @@ class __asio_devices {
   mutable int _index{0};
 };
 
+optional<audio_device> get_default_audio_input_device() {
+  auto& devices = __asio_devices::get();
+  return devices.default_input();
+}
+
+optional<audio_device> get_default_audio_output_device() {
+  auto& devices = __asio_devices::get();
+  return devices.default_output();
+}
+
+audio_device_list get_audio_input_device_list() {
+  auto& devices = __asio_devices::get();
+  return devices.inputs();
+}
+
+audio_device_list get_audio_output_device_list() {
+  auto& devices = __asio_devices::get();
+  return devices.outputs();
+}
+
+template<class F, class /* = enable_if_t<is_nothrow_invocable_v<F>> */>
+void set_audio_device_list_callback(audio_device_list_event, F&&) {
+  // TODO: Implement this.
+}
+
 _LIBSTDAUDIO_NAMESPACE_END
diff --git a/include/audio_backend/__asio_backend.h b/include/audio_backend/__asio_backend.h
deleted file mode 100644
index 681392a..0000000
--- a/include/audio_backend/__asio_backend.h
+++ /dev/null
@@ -1,37 +0,0 @@
-// libstdaudio
-// Copyright (c) 2018 - 2019 - Timur Doumler, Andy Saul
-// 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 "__asio_audio_device.h"
-
-_LIBSTDAUDIO_NAMESPACE_BEGIN
-
-optional<audio_device> get_default_audio_input_device() {
-  auto& devices = __asio_devices::get();
-  return devices.default_input();
-}
-
-optional<audio_device> get_default_audio_output_device() {
-  auto& devices = __asio_devices::get();
-  return devices.default_output();
-}
-
-audio_device_list get_audio_input_device_list() {
-  auto& devices = __asio_devices::get();
-  return devices.inputs();
-}
-
-audio_device_list get_audio_output_device_list() {
-  auto& devices = __asio_devices::get();
-  return devices.outputs();
-}
-
-template<class F, class /* = enable_if_t<is_nothrow_invocable_v<F>> */>
-void set_audio_device_list_callback(audio_device_list_event, F&&) {
-  // TODO: Implement this.
-}
-
-_LIBSTDAUDIO_NAMESPACE_END

From 42d94df4d40ebed6cc4649db644da7329dc61eb1 Mon Sep 17 00:00:00 2001
From: AndySaul <no_reply>
Date: Sun, 16 Jun 2019 18:30:42 +0100
Subject: [PATCH 96/97] Consolidate all ASIO code in __asio_backend.h

---
 include/audio                                                   | 2 +-
 .../audio_backend/{__asio_audio_device.h => __asio_backend.h}   | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename include/audio_backend/{__asio_audio_device.h => __asio_backend.h} (100%)

diff --git a/include/audio b/include/audio
index 35f07df..2fa467b 100644
--- a/include/audio
+++ b/include/audio
@@ -18,7 +18,7 @@
 #ifdef __APPLE__
   #include <audio_backend/__coreaudio_backend.h>
 #elif defined _WIN32
-  #include <audio_backend/__asio_audio_device.h>
+  #include <audio_backend/__asio_backend.h>
 #else
   #include <audio_backend/__null_backend.h>
 #endif // __APPLE__
diff --git a/include/audio_backend/__asio_audio_device.h b/include/audio_backend/__asio_backend.h
similarity index 100%
rename from include/audio_backend/__asio_audio_device.h
rename to include/audio_backend/__asio_backend.h

From 6b564350444482f02a2ba2d32352e8a227dc2725 Mon Sep 17 00:00:00 2001
From: Andy Saul <andycsaul@gmail.com>
Date: Sun, 16 Jun 2019 19:51:20 +0100
Subject: [PATCH 97/97] Fix hicpp-signed-bitwise warning rather than
 suppressing it

---
 include/audio_backend/__asio_backend.h | 10 ++++------
 test/asio_test.cpp                     | 10 +++++-----
 2 files changed, 9 insertions(+), 11 deletions(-)

diff --git a/include/audio_backend/__asio_backend.h b/include/audio_backend/__asio_backend.h
index fe00b29..8de00a5 100644
--- a/include/audio_backend/__asio_backend.h
+++ b/include/audio_backend/__asio_backend.h
@@ -64,12 +64,10 @@ class alignas(1) __asio_sample<packed24_t> {
 public:
   static constexpr int32_t _scale = 0x7f'ffff;
   __asio_sample() = default;
-  explicit __asio_sample(const int32_t value)
-    : data{static_cast<int8_t>(value & 0xff),         // NOLINT(hicpp-signed-bitwise)
-           static_cast<int8_t>((value >> 8) & 0xff),  // NOLINT(hicpp-signed-bitwise)
-           static_cast<int8_t>((value >> 16) & 0xff)} // NOLINT(hicpp-signed-bitwise)
-  {}
-  explicit __asio_sample(const float value) : __asio_sample{static_cast<int32_t>(value * _scale)} {}
+  explicit __asio_sample(const uint32_t value)
+    : data{static_cast<int8_t>(value & 0xffu), static_cast<int8_t>((value >> 8u) & 0xffu), static_cast<int8_t>((value >> 16u) & 0xffu)} {
+  }
+  explicit __asio_sample(const float value) : __asio_sample{static_cast<uint32_t>(value * _scale)} {}
 
   int32_t int_value() const {
     return ((data[2] << 24) >> 8) | ((data[1] << 8) & 0xff00) | (data[0] & 0xff); // NOLINT(hicpp-signed-bitwise)
diff --git a/test/asio_test.cpp b/test/asio_test.cpp
index 706e8a0..70ebcca 100644
--- a/test/asio_test.cpp
+++ b/test/asio_test.cpp
@@ -51,14 +51,14 @@ TEST_CASE("Converts integer samples to floating point samples", "[asio]") {
   }
 
   SECTION("Converts from 24-bit samples") {
-    CHECK(__asio_sample<packed24_t>(0).float_value() == 0.f);
-    CHECK(__asio_sample<packed24_t>(0x7f'ffff).float_value() == 1.f);
-    CHECK(__asio_sample<packed24_t>(-0x7f'ffff).float_value() == -1.f);
+    CHECK(__asio_sample<packed24_t>(0u).float_value() == 0.f);
+    CHECK(__asio_sample<packed24_t>(0x7f'ffffu).float_value() == 1.f);
+    CHECK(__asio_sample<packed24_t>(static_cast<uint32_t>(-0x7f'ffff)).float_value() == -1.f);
 
-    const auto half = __asio_sample<packed24_t>(0x7f'ffff / 2).float_value();
+    const auto half = __asio_sample<packed24_t>(0x7f'ffffu / 2).float_value();
     CHECK(Approx(half) == 0.5f);
 
-    const auto minus_half = __asio_sample<packed24_t>(-0x7f'ffff / 2).float_value();
+    const auto minus_half = __asio_sample<packed24_t>(static_cast<uint32_t>(-0x7f'ffff)/ 2).float_value();
     CHECK(Approx(minus_half) == -0.5f);
   }