Run .clang-format

Format all the code under `include` and `src` except those files under
`src/speex` with style setting in `.clang-format` file by the following
script:

```sh

FILE_LIST="$(find "include" "src" -not -path "src/speex/*" | grep -E ".*(\.cpp|\.c|\.h|\.hpp|\.hh)$")"

echo "Files found to format:\n---\n$FILE_LIST\n---"

clang-format --verbose -i $FILE_LIST
```

41 files changed, 4390 insertions, 4131 deletions

diff --git a/src/android/audiotrack_definitions.h b/src/android/audiotrack_definitions.h
index cd50153..f6b6931 100644
--- a/src/android/audiotrack_definitions.h
+++ b/src/android/audiotrack_definitions.h
@@ -22,23 +22,25 @@
  */
 
 /*
- * From https://android.googlesource.com/platform/frameworks/base/+/android-2.2.3_r2.1/include/utils/Errors.h
+ * From
+ * https://android.googlesource.com/platform/frameworks/base/+/android-2.2.3_r2.1/include/utils/Errors.h
  */
 typedef int32_t status_t;
 
 /*
- * From https://android.googlesource.com/platform/frameworks/base/+/android-2.2.3_r2.1/include/media/AudioTrack.h
+ * From
+ * https://android.googlesource.com/platform/frameworks/base/+/android-2.2.3_r2.1/include/media/AudioTrack.h
  */
 struct Buffer {
-  uint32_t    flags;
-  int         channelCount;
-  int         format;
-  size_t      frameCount;
-  size_t      size;
+  uint32_t flags;
+  int channelCount;
+  int format;
+  size_t frameCount;
+  size_t size;
   union {
-    void*       raw;
-    short*      i16;
-    int8_t*     i8;
+    void * raw;
+    short * i16;
+    int8_t * i8;
   };
 };
 
@@ -52,25 +54,28 @@ enum event_type {
 };
 
 /**
- * From https://android.googlesource.com/platform/frameworks/base/+/android-2.2.3_r2.1/include/media/AudioSystem.h
- * and 
+ * From
+ * https://android.googlesource.com/platform/frameworks/base/+/android-2.2.3_r2.1/include/media/AudioSystem.h
+ * and
  * https://android.googlesource.com/platform/system/core/+/android-4.2.2_r1/include/system/audio.h
  */
 
 #define AUDIO_STREAM_TYPE_MUSIC 3
 
 enum {
-  AUDIO_CHANNEL_OUT_FRONT_LEFT_ICS  = 0x1,
+  AUDIO_CHANNEL_OUT_FRONT_LEFT_ICS = 0x1,
   AUDIO_CHANNEL_OUT_FRONT_RIGHT_ICS = 0x2,
-  AUDIO_CHANNEL_OUT_MONO_ICS     = AUDIO_CHANNEL_OUT_FRONT_LEFT_ICS,
-  AUDIO_CHANNEL_OUT_STEREO_ICS   = (AUDIO_CHANNEL_OUT_FRONT_LEFT_ICS | AUDIO_CHANNEL_OUT_FRONT_RIGHT_ICS)
+  AUDIO_CHANNEL_OUT_MONO_ICS = AUDIO_CHANNEL_OUT_FRONT_LEFT_ICS,
+  AUDIO_CHANNEL_OUT_STEREO_ICS =
+      (AUDIO_CHANNEL_OUT_FRONT_LEFT_ICS | AUDIO_CHANNEL_OUT_FRONT_RIGHT_ICS)
 } AudioTrack_ChannelMapping_ICS;
 
 enum {
   AUDIO_CHANNEL_OUT_FRONT_LEFT_Legacy = 0x4,
   AUDIO_CHANNEL_OUT_FRONT_RIGHT_Legacy = 0x8,
   AUDIO_CHANNEL_OUT_MONO_Legacy = AUDIO_CHANNEL_OUT_FRONT_LEFT_Legacy,
-  AUDIO_CHANNEL_OUT_STEREO_Legacy = (AUDIO_CHANNEL_OUT_FRONT_LEFT_Legacy | AUDIO_CHANNEL_OUT_FRONT_RIGHT_Legacy)
+  AUDIO_CHANNEL_OUT_STEREO_Legacy = (AUDIO_CHANNEL_OUT_FRONT_LEFT_Legacy |
+                                     AUDIO_CHANNEL_OUT_FRONT_RIGHT_Legacy)
 } AudioTrack_ChannelMapping_Legacy;
 
 typedef enum {
@@ -78,4 +83,3 @@ typedef enum {
   AUDIO_FORMAT_PCM_SUB_16_BIT = 0x1,
   AUDIO_FORMAT_PCM_16_BIT = (AUDIO_FORMAT_PCM | AUDIO_FORMAT_PCM_SUB_16_BIT),
 } AudioTrack_SampleType;
-
diff --git a/src/android/cubeb-output-latency.h b/src/android/cubeb-output-latency.h
index 2128cd1..870a884 100644
--- a/src/android/cubeb-output-latency.h
+++ b/src/android/cubeb-output-latency.h
@@ -1,9 +1,9 @@
 #ifndef _CUBEB_OUTPUT_LATENCY_H_
 #define _CUBEB_OUTPUT_LATENCY_H_
 
-#include <stdbool.h>
-#include "cubeb_media_library.h"
 #include "../cubeb-jni.h"
+#include "cubeb_media_library.h"
+#include <stdbool.h>
 
 struct output_latency_function {
   media_lib * from_lib;
@@ -23,7 +23,7 @@ cubeb_output_latency_load_method(int version)
 
   ol->version = version;
 
-  if (ol->version > ANDROID_JELLY_BEAN_MR1_4_2){
+  if (ol->version > ANDROID_JELLY_BEAN_MR1_4_2) {
     ol->from_jni = cubeb_jni_init();
     return ol;
   }
@@ -36,7 +36,7 @@ bool
 cubeb_output_latency_method_is_loaded(output_latency_function * ol)
 {
   assert(ol);
-  if (ol->version > ANDROID_JELLY_BEAN_MR1_4_2){
+  if (ol->version > ANDROID_JELLY_BEAN_MR1_4_2) {
     return !!ol->from_jni;
   }
 
@@ -66,7 +66,7 @@ cubeb_get_output_latency(output_latency_function * ol)
 {
   assert(cubeb_output_latency_method_is_loaded(ol));
 
-  if (ol->version > ANDROID_JELLY_BEAN_MR1_4_2){
+  if (ol->version > ANDROID_JELLY_BEAN_MR1_4_2) {
     return cubeb_get_output_latency_from_jni(ol->from_jni);
   }
 
diff --git a/src/android/cubeb_media_library.h b/src/android/cubeb_media_library.h
index ab21b77..27fbc86 100644
--- a/src/android/cubeb_media_library.h
+++ b/src/android/cubeb_media_library.h
@@ -3,7 +3,7 @@
 
 struct media_lib {
   void * libmedia;
-  int32_t (* get_output_latency)(uint32_t * latency, int stream_type);
+  int32_t (*get_output_latency)(uint32_t * latency, int stream_type);
 };
 
 typedef struct media_lib media_lib;
@@ -17,15 +17,17 @@ cubeb_load_media_library()
     return NULL;
   }
 
-  // Get the latency, in ms, from AudioFlinger. First, try the most recent signature.
-  // status_t AudioSystem::getOutputLatency(uint32_t* latency, audio_stream_type_t streamType)
-  ml.get_output_latency =
-    dlsym(ml.libmedia, "_ZN7android11AudioSystem16getOutputLatencyEPj19audio_stream_type_t");
+  // Get the latency, in ms, from AudioFlinger. First, try the most recent
+  // signature. status_t AudioSystem::getOutputLatency(uint32_t* latency,
+  // audio_stream_type_t streamType)
+  ml.get_output_latency = dlsym(
+      ml.libmedia,
+      "_ZN7android11AudioSystem16getOutputLatencyEPj19audio_stream_type_t");
   if (!ml.get_output_latency) {
     // In case of failure, try the signature from legacy version.
     // status_t AudioSystem::getOutputLatency(uint32_t* latency, int streamType)
     ml.get_output_latency =
-      dlsym(ml.libmedia, "_ZN7android11AudioSystem16getOutputLatencyEPji");
+        dlsym(ml.libmedia, "_ZN7android11AudioSystem16getOutputLatencyEPji");
     if (!ml.get_output_latency) {
       return NULL;
     }
diff --git a/src/android/sles_definitions.h b/src/android/sles_definitions.h
index 06d2e8d..b107003 100644
--- a/src/android/sles_definitions.h
+++ b/src/android/sles_definitions.h
@@ -29,23 +29,23 @@
 
 /** Audio recording preset */
 /** Audio recording preset key */
-#define SL_ANDROID_KEY_RECORDING_PRESET ((const SLchar*) "androidRecordingPreset")
+#define SL_ANDROID_KEY_RECORDING_PRESET                                        \
+  ((const SLchar *)"androidRecordingPreset")
 /** Audio recording preset values */
 /**   preset "none" cannot be set, it is used to indicate the current settings
  *     do not match any of the presets. */
-#define SL_ANDROID_RECORDING_PRESET_NONE                ((SLuint32) 0x00000000)
+#define SL_ANDROID_RECORDING_PRESET_NONE ((SLuint32)0x00000000)
 /**   generic recording configuration on the platform */
-#define SL_ANDROID_RECORDING_PRESET_GENERIC             ((SLuint32) 0x00000001)
+#define SL_ANDROID_RECORDING_PRESET_GENERIC ((SLuint32)0x00000001)
 /**   uses the microphone audio source with the same orientation as the camera
  *     if available, the main device microphone otherwise */
-#define SL_ANDROID_RECORDING_PRESET_CAMCORDER           ((SLuint32) 0x00000002)
+#define SL_ANDROID_RECORDING_PRESET_CAMCORDER ((SLuint32)0x00000002)
 /**   uses the main microphone tuned for voice recognition */
-#define SL_ANDROID_RECORDING_PRESET_VOICE_RECOGNITION   ((SLuint32) 0x00000003)
+#define SL_ANDROID_RECORDING_PRESET_VOICE_RECOGNITION ((SLuint32)0x00000003)
 /**   uses the main microphone tuned for audio communications */
-#define SL_ANDROID_RECORDING_PRESET_VOICE_COMMUNICATION ((SLuint32) 0x00000004)
+#define SL_ANDROID_RECORDING_PRESET_VOICE_COMMUNICATION ((SLuint32)0x00000004)
 /**   uses the main microphone unprocessed */
-#define SL_ANDROID_RECORDING_PRESET_UNPROCESSED         ((SLuint32) 0x00000005)
-
+#define SL_ANDROID_RECORDING_PRESET_UNPROCESSED ((SLuint32)0x00000005)
 
 /*---------------------------------------------------------------------------*/
 /* Android AudioPlayer configuration                                         */
@@ -53,22 +53,21 @@
 
 /** Audio playback stream type */
 /** Audio playback stream type key */
-#define SL_ANDROID_KEY_STREAM_TYPE ((const SLchar*) "androidPlaybackStreamType")
+#define SL_ANDROID_KEY_STREAM_TYPE ((const SLchar *)"androidPlaybackStreamType")
 
 /** Audio playback stream type  values */
 /*      same as android.media.AudioManager.STREAM_VOICE_CALL */
-#define SL_ANDROID_STREAM_VOICE        ((SLint32) 0x00000000)
+#define SL_ANDROID_STREAM_VOICE ((SLint32)0x00000000)
 /*      same as android.media.AudioManager.STREAM_SYSTEM */
-#define SL_ANDROID_STREAM_SYSTEM       ((SLint32) 0x00000001)
+#define SL_ANDROID_STREAM_SYSTEM ((SLint32)0x00000001)
 /*      same as android.media.AudioManager.STREAM_RING */
-#define SL_ANDROID_STREAM_RING         ((SLint32) 0x00000002)
+#define SL_ANDROID_STREAM_RING ((SLint32)0x00000002)
 /*      same as android.media.AudioManager.STREAM_MUSIC */
-#define SL_ANDROID_STREAM_MEDIA        ((SLint32) 0x00000003)
+#define SL_ANDROID_STREAM_MEDIA ((SLint32)0x00000003)
 /*      same as android.media.AudioManager.STREAM_ALARM */
-#define SL_ANDROID_STREAM_ALARM        ((SLint32) 0x00000004)
+#define SL_ANDROID_STREAM_ALARM ((SLint32)0x00000004)
 /*      same as android.media.AudioManager.STREAM_NOTIFICATION */
-#define SL_ANDROID_STREAM_NOTIFICATION ((SLint32) 0x00000005)
-
+#define SL_ANDROID_STREAM_NOTIFICATION ((SLint32)0x00000005)
 
 /*---------------------------------------------------------------------------*/
 /* Android AudioPlayer and AudioRecorder configuration                       */
@@ -85,18 +84,21 @@
  * granted or not.
  */
 /** Audio Performance mode key */
-#define SL_ANDROID_KEY_PERFORMANCE_MODE ((const SLchar*) "androidPerformanceMode")
+#define SL_ANDROID_KEY_PERFORMANCE_MODE                                        \
+  ((const SLchar *)"androidPerformanceMode")
 
 /** Audio performance values */
-/*      No specific performance requirement. Allows HW and SW pre/post processing. */
-#define SL_ANDROID_PERFORMANCE_NONE ((SLuint32) 0x00000000)
+/*      No specific performance requirement. Allows HW and SW pre/post
+ * processing. */
+#define SL_ANDROID_PERFORMANCE_NONE ((SLuint32)0x00000000)
 /*      Priority given to latency. No HW or software pre/post processing.
  *      This is the default if no performance mode is specified. */
-#define SL_ANDROID_PERFORMANCE_LATENCY ((SLuint32) 0x00000001)
-/*      Priority given to latency while still allowing HW pre and post processing. */
-#define SL_ANDROID_PERFORMANCE_LATENCY_EFFECTS ((SLuint32) 0x00000002)
+#define SL_ANDROID_PERFORMANCE_LATENCY ((SLuint32)0x00000001)
+/*      Priority given to latency while still allowing HW pre and post
+ * processing. */
+#define SL_ANDROID_PERFORMANCE_LATENCY_EFFECTS ((SLuint32)0x00000002)
 /*      Priority given to power saving if latency is not a concern.
  *      Allows HW and SW pre/post processing. */
-#define SL_ANDROID_PERFORMANCE_POWER_SAVING ((SLuint32) 0x00000003)
+#define SL_ANDROID_PERFORMANCE_POWER_SAVING ((SLuint32)0x00000003)
 
 #endif /* OPENSL_ES_ANDROIDCONFIGURATION_H_ */
diff --git a/src/cubeb-internal.h b/src/cubeb-internal.h
index 406dca4..79326e1 100644
--- a/src/cubeb-internal.h
+++ b/src/cubeb-internal.h
@@ -8,8 +8,8 @@
 #define CUBEB_INTERNAL_0eb56756_4e20_4404_a76d_42bf88cd15a5
 
 #include "cubeb/cubeb.h"
-#include "cubeb_log.h"
 #include "cubeb_assert.h"
+#include "cubeb_log.h"
 #include <stdio.h>
 #include <string.h>
 
@@ -21,7 +21,7 @@
 #define CLANG_ANALYZER_NORETURN
 #endif // ifndef CLANG_ANALYZER_NORETURN
 #endif // __has_feature(attribute_analyzer_noreturn)
-#else // __clang__
+#else  // __clang__
 #define CLANG_ANALYZER_NORETURN
 #endif
 
@@ -34,47 +34,41 @@ extern "C" {
 #endif
 
 struct cubeb_ops {
-  int (* init)(cubeb ** context, char const * context_name);
-  char const * (* get_backend_id)(cubeb * context);
-  int (* get_max_channel_count)(cubeb * context, uint32_t * max_channels);
-  int (* get_min_latency)(cubeb * context,
-                          cubeb_stream_params params,
-                          uint32_t * latency_ms);
-  int (* get_preferred_sample_rate)(cubeb * context, uint32_t * rate);
-  int (* enumerate_devices)(cubeb * context, cubeb_device_type type,
-                            cubeb_device_collection * collection);
-  int (* device_collection_destroy)(cubeb * context,
-                                    cubeb_device_collection * collection);
-  void (* destroy)(cubeb * context);
-  int (* stream_init)(cubeb * context,
-                      cubeb_stream ** stream,
-                      char const * stream_name,
-                      cubeb_devid input_device,
-                      cubeb_stream_params * input_stream_params,
-                      cubeb_devid output_device,
-                      cubeb_stream_params * output_stream_params,
-                      unsigned int latency,
-                      cubeb_data_callback data_callback,
-                      cubeb_state_callback state_callback,
-                      void * user_ptr);
-  void (* stream_destroy)(cubeb_stream * stream);
-  int (* stream_start)(cubeb_stream * stream);
-  int (* stream_stop)(cubeb_stream * stream);
-  int (* stream_get_position)(cubeb_stream * stream, uint64_t * position);
-  int (* stream_get_latency)(cubeb_stream * stream, uint32_t * latency);
-  int (* stream_get_input_latency)(cubeb_stream * stream, uint32_t * latency);
-  int (* stream_set_volume)(cubeb_stream * stream, float volumes);
-  int (* stream_set_name)(cubeb_stream * stream, char const * stream_name);
-  int (* stream_get_current_device)(cubeb_stream * stream,
-                                    cubeb_device ** const device);
-  int (* stream_device_destroy)(cubeb_stream * stream,
-                                cubeb_device * device);
-  int (* stream_register_device_changed_callback)(cubeb_stream * stream,
-                                                  cubeb_device_changed_callback device_changed_callback);
-  int (* register_device_collection_changed)(cubeb * context,
-                                             cubeb_device_type devtype,
-                                             cubeb_device_collection_changed_callback callback,
-                                             void * user_ptr);
+  int (*init)(cubeb ** context, char const * context_name);
+  char const * (*get_backend_id)(cubeb * context);
+  int (*get_max_channel_count)(cubeb * context, uint32_t * max_channels);
+  int (*get_min_latency)(cubeb * context, cubeb_stream_params params,
+                         uint32_t * latency_ms);
+  int (*get_preferred_sample_rate)(cubeb * context, uint32_t * rate);
+  int (*enumerate_devices)(cubeb * context, cubeb_device_type type,
+                           cubeb_device_collection * collection);
+  int (*device_collection_destroy)(cubeb * context,
+                                   cubeb_device_collection * collection);
+  void (*destroy)(cubeb * context);
+  int (*stream_init)(cubeb * context, cubeb_stream ** stream,
+                     char const * stream_name, cubeb_devid input_device,
+                     cubeb_stream_params * input_stream_params,
+                     cubeb_devid output_device,
+                     cubeb_stream_params * output_stream_params,
+                     unsigned int latency, cubeb_data_callback data_callback,
+                     cubeb_state_callback state_callback, void * user_ptr);
+  void (*stream_destroy)(cubeb_stream * stream);
+  int (*stream_start)(cubeb_stream * stream);
+  int (*stream_stop)(cubeb_stream * stream);
+  int (*stream_get_position)(cubeb_stream * stream, uint64_t * position);
+  int (*stream_get_latency)(cubeb_stream * stream, uint32_t * latency);
+  int (*stream_get_input_latency)(cubeb_stream * stream, uint32_t * latency);
+  int (*stream_set_volume)(cubeb_stream * stream, float volumes);
+  int (*stream_set_name)(cubeb_stream * stream, char const * stream_name);
+  int (*stream_get_current_device)(cubeb_stream * stream,
+                                   cubeb_device ** const device);
+  int (*stream_device_destroy)(cubeb_stream * stream, cubeb_device * device);
+  int (*stream_register_device_changed_callback)(
+      cubeb_stream * stream,
+      cubeb_device_changed_callback device_changed_callback);
+  int (*register_device_collection_changed)(
+      cubeb * context, cubeb_device_type devtype,
+      cubeb_device_collection_changed_callback callback, void * user_ptr);
 };
 
 #endif /* CUBEB_INTERNAL_0eb56756_4e20_4404_a76d_42bf88cd15a5 */
diff --git a/src/cubeb-jni.cpp b/src/cubeb-jni.cpp
index a506696..d503266 100644
--- a/src/cubeb-jni.cpp
+++ b/src/cubeb-jni.cpp
@@ -1,6 +1,6 @@
+#include "cubeb-jni-instances.h"
 #include "jni.h"
 #include <assert.h>
-#include "cubeb-jni-instances.h"
 
 #define AUDIO_STREAM_TYPE_MUSIC 3
 
@@ -10,8 +10,7 @@ struct cubeb_jni {
   jmethodID s_get_output_latency_id = nullptr;
 };
 
-extern "C"
-cubeb_jni *
+extern "C" cubeb_jni *
 cubeb_jni_init()
 {
   jobject ctx_obj = cubeb_jni_get_context_instance();
@@ -23,18 +22,28 @@ cubeb_jni_init()
   cubeb_jni * cubeb_jni_ptr = new cubeb_jni;
   assert(cubeb_jni_ptr);
 
-  // Find the audio manager object and make it global to call it from another method
+  // Find the audio manager object and make it global to call it from another
+  // method
   jclass context_class = jni_env->FindClass("android/content/Context");
-  jfieldID audio_service_field = jni_env->GetStaticFieldID(context_class, "AUDIO_SERVICE", "Ljava/lang/String;");
-  jstring jstr = (jstring)jni_env->GetStaticObjectField(context_class, audio_service_field);
-  jmethodID get_system_service_id = jni_env->GetMethodID(context_class, "getSystemService", "(Ljava/lang/String;)Ljava/lang/Object;");
-  jobject audio_manager_obj = jni_env->CallObjectMethod(ctx_obj, get_system_service_id, jstr);
-  cubeb_jni_ptr->s_audio_manager_obj = reinterpret_cast<jobject>(jni_env->NewGlobalRef(audio_manager_obj));
+  jfieldID audio_service_field = jni_env->GetStaticFieldID(
+      context_class, "AUDIO_SERVICE", "Ljava/lang/String;");
+  jstring jstr = (jstring)jni_env->GetStaticObjectField(context_class,
+                                                        audio_service_field);
+  jmethodID get_system_service_id =
+      jni_env->GetMethodID(context_class, "getSystemService",
+                           "(Ljava/lang/String;)Ljava/lang/Object;");
+  jobject audio_manager_obj =
+      jni_env->CallObjectMethod(ctx_obj, get_system_service_id, jstr);
+  cubeb_jni_ptr->s_audio_manager_obj =
+      reinterpret_cast<jobject>(jni_env->NewGlobalRef(audio_manager_obj));
 
-  // Make the audio manager class a global reference in order to preserve method id
+  // Make the audio manager class a global reference in order to preserve method
+  // id
   jclass audio_manager_class = jni_env->FindClass("android/media/AudioManager");
-  cubeb_jni_ptr->s_audio_manager_class = reinterpret_cast<jclass>(jni_env->NewGlobalRef(audio_manager_class));
-  cubeb_jni_ptr->s_get_output_latency_id = jni_env->GetMethodID (audio_manager_class, "getOutputLatency", "(I)I");
+  cubeb_jni_ptr->s_audio_manager_class =
+      reinterpret_cast<jclass>(jni_env->NewGlobalRef(audio_manager_class));
+  cubeb_jni_ptr->s_get_output_latency_id =
+      jni_env->GetMethodID(audio_manager_class, "getOutputLatency", "(I)I");
 
   jni_env->DeleteLocalRef(ctx_obj);
   jni_env->DeleteLocalRef(context_class);
@@ -45,16 +54,19 @@ cubeb_jni_init()
   return cubeb_jni_ptr;
 }
 
-extern "C"
-int cubeb_get_output_latency_from_jni(cubeb_jni * cubeb_jni_ptr)
+extern "C" int
+cubeb_get_output_latency_from_jni(cubeb_jni * cubeb_jni_ptr)
 {
   assert(cubeb_jni_ptr);
   JNIEnv * jni_env = cubeb_get_jni_env_for_thread();
-  return jni_env->CallIntMethod(cubeb_jni_ptr->s_audio_manager_obj, cubeb_jni_ptr->s_get_output_latency_id, AUDIO_STREAM_TYPE_MUSIC); //param: AudioManager.STREAM_MUSIC
+  return jni_env->CallIntMethod(
+      cubeb_jni_ptr->s_audio_manager_obj,
+      cubeb_jni_ptr->s_get_output_latency_id,
+      AUDIO_STREAM_TYPE_MUSIC); // param: AudioManager.STREAM_MUSIC
 }
 
-extern "C"
-void cubeb_jni_destroy(cubeb_jni * cubeb_jni_ptr)
+extern "C" void
+cubeb_jni_destroy(cubeb_jni * cubeb_jni_ptr)
 {
   assert(cubeb_jni_ptr);
 
diff --git a/src/cubeb-jni.h b/src/cubeb-jni.h
index 8c7ddb6..c4a712a 100644
--- a/src/cubeb-jni.h
+++ b/src/cubeb-jni.h
@@ -3,8 +3,11 @@
 
 typedef struct cubeb_jni cubeb_jni;
 
-cubeb_jni * cubeb_jni_init();
-int cubeb_get_output_latency_from_jni(cubeb_jni * cubeb_jni_ptr);
-void cubeb_jni_destroy(cubeb_jni * cubeb_jni_ptr);
+cubeb_jni *
+cubeb_jni_init();
+int
+cubeb_get_output_latency_from_jni(cubeb_jni * cubeb_jni_ptr);
+void
+cubeb_jni_destroy(cubeb_jni * cubeb_jni_ptr);
 
 #endif // _CUBEB_JNI_H_
diff --git a/src/cubeb-sles.h b/src/cubeb-sles.h
index ac22150..ca93543 100644
--- a/src/cubeb-sles.h
+++ b/src/cubeb-sles.h
@@ -10,27 +10,22 @@
 #include <SLES/OpenSLES.h>
 
 static SLresult
-cubeb_get_sles_engine(SLObjectItf * pEngine,
-                      SLuint32 numOptions,
+cubeb_get_sles_engine(SLObjectItf * pEngine, SLuint32 numOptions,
                       const SLEngineOption * pEngineOptions,
                       SLuint32 numInterfaces,
                       const SLInterfaceID * pInterfaceIds,
                       const SLboolean * pInterfaceRequired)
 {
-  return slCreateEngine(pEngine,
-                        numOptions,
-                        pEngineOptions,
-                        numInterfaces,
-                        pInterfaceIds,
-                        pInterfaceRequired);
+  return slCreateEngine(pEngine, numOptions, pEngineOptions, numInterfaces,
+                        pInterfaceIds, pInterfaceRequired);
 }
 
 static void
 cubeb_destroy_sles_engine(SLObjectItf * self)
 {
   if (*self != NULL) {
-      (**self)->Destroy(*self);
-      *self = NULL;
+    (**self)->Destroy(*self);
+    *self = NULL;
   }
 }
 
diff --git a/src/cubeb.c b/src/cubeb.c
index c43c996..b3d32ee 100644
--- a/src/cubeb.c
+++ b/src/cubeb.c
@@ -5,14 +5,14 @@
  * accompanying file LICENSE for details.
  */
 #undef NDEBUG
+#include "cubeb/cubeb.h"
+#include "cubeb-internal.h"
 #include <assert.h>
 #include <stddef.h>
 #include <stdlib.h>
 #include <string.h>
-#include "cubeb/cubeb.h"
-#include "cubeb-internal.h"
 
-#define NELEMS(x) ((int) (sizeof(x) / sizeof(x[0])))
+#define NELEMS(x) ((int)(sizeof(x) / sizeof(x[0])))
 
 struct cubeb {
   struct cubeb_ops * ops;
@@ -28,49 +28,64 @@ struct cubeb_stream {
 };
 
 #if defined(USE_PULSE)
-int pulse_init(cubeb ** context, char const * context_name);
+int
+pulse_init(cubeb ** context, char const * context_name);
 #endif
 #if defined(USE_PULSE_RUST)
-int pulse_rust_init(cubeb ** contet, char const * context_name);
+int
+pulse_rust_init(cubeb ** contet, char const * context_name);
 #endif
 #if defined(USE_JACK)
-int jack_init (cubeb ** context, char const * context_name);
+int
+jack_init(cubeb ** context, char const * context_name);
 #endif
 #if defined(USE_ALSA)
-int alsa_init(cubeb ** context, char const * context_name);
+int
+alsa_init(cubeb ** context, char const * context_name);
 #endif
 #if defined(USE_AUDIOUNIT)
-int audiounit_init(cubeb ** context, char const * context_name);
+int
+audiounit_init(cubeb ** context, char const * context_name);
 #endif
 #if defined(USE_AUDIOUNIT_RUST)
-int audiounit_rust_init(cubeb ** contet, char const * context_name);
+int
+audiounit_rust_init(cubeb ** contet, char const * context_name);
 #endif
 #if defined(USE_WINMM)
-int winmm_init(cubeb ** context, char const * context_name);
+int
+winmm_init(cubeb ** context, char const * context_name);
 #endif
 #if defined(USE_WASAPI)
-int wasapi_init(cubeb ** context, char const * context_name);
+int
+wasapi_init(cubeb ** context, char const * context_name);
 #endif
 #if defined(USE_SNDIO)
-int sndio_init(cubeb ** context, char const * context_name);
+int
+sndio_init(cubeb ** context, char const * context_name);
 #endif
 #if defined(USE_SUN)
-int sun_init(cubeb ** context, char const * context_name);
+int
+sun_init(cubeb ** context, char const * context_name);
 #endif
 #if defined(USE_OPENSL)
-int opensl_init(cubeb ** context, char const * context_name);
+int
+opensl_init(cubeb ** context, char const * context_name);
 #endif
 #if defined(USE_OSS)
-int oss_init(cubeb ** context, char const * context_name);
+int
+oss_init(cubeb ** context, char const * context_name);
 #endif
 #if defined(USE_AAUDIO)
-int aaudio_init(cubeb ** context, char const * context_name);
+int
+aaudio_init(cubeb ** context, char const * context_name);
 #endif
 #if defined(USE_AUDIOTRACK)
-int audiotrack_init(cubeb ** context, char const * context_name);
+int
+audiotrack_init(cubeb ** context, char const * context_name);
 #endif
 #if defined(USE_KAI)
-int kai_init(cubeb ** context, char const * context_name);
+int
+kai_init(cubeb ** context, char const * context_name);
 #endif
 
 static int
@@ -79,28 +94,32 @@ validate_stream_params(cubeb_stream_params * input_stream_params,
 {
   XASSERT(input_stream_params || output_stream_params);
   if (output_stream_params) {
-    if (output_stream_params->rate < 1000 || output_stream_params->rate > 192000 ||
-        output_stream_params->channels < 1 || output_stream_params->channels > UINT8_MAX) {
+    if (output_stream_params->rate < 1000 ||
+        output_stream_params->rate > 192000 ||
+        output_stream_params->channels < 1 ||
+        output_stream_params->channels > UINT8_MAX) {
       return CUBEB_ERROR_INVALID_FORMAT;
     }
   }
   if (input_stream_params) {
-    if (input_stream_params->rate < 1000 || input_stream_params->rate > 192000 ||
-        input_stream_params->channels < 1 || input_stream_params->channels > UINT8_MAX) {
+    if (input_stream_params->rate < 1000 ||
+        input_stream_params->rate > 192000 ||
+        input_stream_params->channels < 1 ||
+        input_stream_params->channels > UINT8_MAX) {
       return CUBEB_ERROR_INVALID_FORMAT;
     }
   }
   // Rate and sample format must be the same for input and output, if using a
   // duplex stream
   if (input_stream_params && output_stream_params) {
-    if (input_stream_params->rate != output_stream_params->rate  ||
+    if (input_stream_params->rate != output_stream_params->rate ||
         input_stream_params->format != output_stream_params->format) {
       return CUBEB_ERROR_INVALID_FORMAT;
     }
   }
 
-  cubeb_stream_params * params = input_stream_params ?
-                                 input_stream_params : output_stream_params;
+  cubeb_stream_params * params =
+      input_stream_params ? input_stream_params : output_stream_params;
 
   switch (params->format) {
   case CUBEB_SAMPLE_S16LE:
@@ -123,9 +142,10 @@ validate_latency(int latency)
 }
 
 int
-cubeb_init(cubeb ** context, char const * context_name, char const * backend_name)
+cubeb_init(cubeb ** context, char const * context_name,
+           char const * backend_name)
 {
-  int (* init_oneshot)(cubeb **, char const *) = NULL;
+  int (*init_oneshot)(cubeb **, char const *) = NULL;
 
   if (backend_name != NULL) {
     if (!strcmp(backend_name, "pulse")) {
@@ -193,7 +213,7 @@ cubeb_init(cubeb ** context, char const * context_name, char const * backend_nam
     }
   }
 
-  int (* default_init[])(cubeb **, char const *) = {
+  int (*default_init[])(cubeb **, char const *) = {
     /*
      * init_oneshot must be at the top to allow user
      * to override all other choices
@@ -214,7 +234,7 @@ cubeb_init(cubeb ** context, char const * context_name, char const * backend_nam
 #if defined(USE_ALSA)
     alsa_init,
 #endif
-#if defined (USE_OSS)
+#if defined(USE_OSS)
     oss_init,
 #endif
 #if defined(USE_AUDIOUNIT_RUST)
@@ -235,8 +255,8 @@ cubeb_init(cubeb ** context, char const * context_name, char const * backend_nam
 #if defined(USE_OPENSL)
     opensl_init,
 #endif
-    // TODO: should probably be preferred over OpenSLES when available.
-    // Initialization will fail on old android devices.
+  // TODO: should probably be preferred over OpenSLES when available.
+  // Initialization will fail on old android devices.
 #if defined(USE_AAUDIO)
     aaudio_init,
 #endif
@@ -253,7 +273,7 @@ cubeb_init(cubeb ** context, char const * context_name, char const * backend_nam
     return CUBEB_ERROR_INVALID_PARAMETER;
   }
 
-#define OK(fn) assert((* context)->ops->fn)
+#define OK(fn) assert((*context)->ops->fn)
   for (i = 0; i < NELEMS(default_init); ++i) {
     if (default_init[i] && default_init[i](context, context_name) == CUBEB_OK) {
       /* Assert that the minimal API is implemented. */
@@ -295,7 +315,8 @@ cubeb_get_max_channel_count(cubeb * context, uint32_t * max_channels)
 }
 
 int
-cubeb_get_min_latency(cubeb * context, cubeb_stream_params * params, uint32_t * latency_ms)
+cubeb_get_min_latency(cubeb * context, cubeb_stream_params * params,
+                      uint32_t * latency_ms)
 {
   if (!context || !params || !latency_ms) {
     return CUBEB_ERROR_INVALID_PARAMETER;
@@ -333,15 +354,13 @@ cubeb_destroy(cubeb * context)
 }
 
 int
-cubeb_stream_init(cubeb * context, cubeb_stream ** stream, char const * stream_name,
-                  cubeb_devid input_device,
+cubeb_stream_init(cubeb * context, cubeb_stream ** stream,
+                  char const * stream_name, cubeb_devid input_device,
                   cubeb_stream_params * input_stream_params,
                   cubeb_devid output_device,
                   cubeb_stream_params * output_stream_params,
-                  unsigned int latency,
-                  cubeb_data_callback data_callback,
-                  cubeb_state_callback state_callback,
-                  void * user_ptr)
+                  unsigned int latency, cubeb_data_callback data_callback,
+                  cubeb_state_callback state_callback, void * user_ptr)
 {
   int r;
 
@@ -349,24 +368,20 @@ cubeb_stream_init(cubeb * context, cubeb_stream ** stream, char const * stream_n
     return CUBEB_ERROR_INVALID_PARAMETER;
   }
 
-  if ((r = validate_stream_params(input_stream_params, output_stream_params)) != CUBEB_OK ||
+  if ((r = validate_stream_params(input_stream_params, output_stream_params)) !=
+          CUBEB_OK ||
       (r = validate_latency(latency)) != CUBEB_OK) {
     return r;
   }
 
-  r = context->ops->stream_init(context, stream, stream_name,
-                                input_device,
-                                input_stream_params,
-                                output_device,
-                                output_stream_params,
-                                latency,
-                                data_callback,
-                                state_callback,
-                                user_ptr);
+  r = context->ops->stream_init(context, stream, stream_name, input_device,
+                                input_stream_params, output_device,
+                                output_stream_params, latency, data_callback,
+                                state_callback, user_ptr);
 
   if (r == CUBEB_ERROR_INVALID_FORMAT) {
-    LOG("Invalid format, %p %p %d %d",
-        output_stream_params, input_stream_params,
+    LOG("Invalid format, %p %p %d %d", output_stream_params,
+        input_stream_params,
         output_stream_params && output_stream_params->format,
         input_stream_params && input_stream_params->format);
   }
@@ -470,8 +485,9 @@ cubeb_stream_set_name(cubeb_stream * stream, char const * stream_name)
   return stream->context->ops->stream_set_name(stream, stream_name);
 }
 
-int cubeb_stream_get_current_device(cubeb_stream * stream,
-                                    cubeb_device ** const device)
+int
+cubeb_stream_get_current_device(cubeb_stream * stream,
+                                cubeb_device ** const device)
 {
   if (!stream || !device) {
     return CUBEB_ERROR_INVALID_PARAMETER;
@@ -484,8 +500,8 @@ int cubeb_stream_get_current_device(cubeb_stream * stream,
   return stream->context->ops->stream_get_current_device(stream, device);
 }
 
-int cubeb_stream_device_destroy(cubeb_stream * stream,
-                                cubeb_device * device)
+int
+cubeb_stream_device_destroy(cubeb_stream * stream, cubeb_device * device)
 {
   if (!stream || !device) {
     return CUBEB_ERROR_INVALID_PARAMETER;
@@ -498,8 +514,10 @@ int cubeb_stream_device_destroy(cubeb_stream * stream,
   return stream->context->ops->stream_device_destroy(stream, device);
 }
 
-int cubeb_stream_register_device_changed_callback(cubeb_stream * stream,
-                                                  cubeb_device_changed_callback device_changed_callback)
+int
+cubeb_stream_register_device_changed_callback(
+    cubeb_stream * stream,
+    cubeb_device_changed_callback device_changed_callback)
 {
   if (!stream) {
     return CUBEB_ERROR_INVALID_PARAMETER;
@@ -509,10 +527,12 @@ int cubeb_stream_register_device_changed_callback(cubeb_stream * stream,
     return CUBEB_ERROR_NOT_SUPPORTED;
   }
 
-  return stream->context->ops->stream_register_device_changed_callback(stream, device_changed_callback);
+  return stream->context->ops->stream_register_device_changed_callback(
+      stream, device_changed_callback);
 }
 
-void * cubeb_stream_user_ptr(cubeb_stream * stream)
+void *
+cubeb_stream_user_ptr(cubeb_stream * stream)
 {
   if (!stream) {
     return NULL;
@@ -521,56 +541,56 @@ void * cubeb_stream_user_ptr(cubeb_stream * stream)
   return stream->user_ptr;
 }
 
-static
-void log_device(cubeb_device_info * device_info)
+static void
+log_device(cubeb_device_info * device_info)
 {
   char devfmts[128] = "";
-  const char * devtype, * devstate, * devdeffmt;
+  const char *devtype, *devstate, *devdeffmt;
 
   switch (device_info->type) {
-    case CUBEB_DEVICE_TYPE_INPUT:
-      devtype = "input";
-      break;
-    case CUBEB_DEVICE_TYPE_OUTPUT:
-      devtype = "output";
-      break;
-    case CUBEB_DEVICE_TYPE_UNKNOWN:
-    default:
-      devtype = "unknown?";
-      break;
+  case CUBEB_DEVICE_TYPE_INPUT:
+    devtype = "input";
+    break;
+  case CUBEB_DEVICE_TYPE_OUTPUT:
+    devtype = "output";
+    break;
+  case CUBEB_DEVICE_TYPE_UNKNOWN:
+  default:
+    devtype = "unknown?";
+    break;
   };
 
   switch (device_info->state) {
-    case CUBEB_DEVICE_STATE_DISABLED:
-      devstate = "disabled";
-      break;
-    case CUBEB_DEVICE_STATE_UNPLUGGED:
-      devstate = "unplugged";
-      break;
-    case CUBEB_DEVICE_STATE_ENABLED:
-      devstate = "enabled";
-      break;
-    default:
-      devstate = "unknown?";
-      break;
+  case CUBEB_DEVICE_STATE_DISABLED:
+    devstate = "disabled";
+    break;
+  case CUBEB_DEVICE_STATE_UNPLUGGED:
+    devstate = "unplugged";
+    break;
+  case CUBEB_DEVICE_STATE_ENABLED:
+    devstate = "enabled";
+    break;
+  default:
+    devstate = "unknown?";
+    break;
   };
 
   switch (device_info->default_format) {
-    case CUBEB_DEVICE_FMT_S16LE:
-      devdeffmt = "S16LE";
-      break;
-    case CUBEB_DEVICE_FMT_S16BE:
-      devdeffmt = "S16BE";
-      break;
-    case CUBEB_DEVICE_FMT_F32LE:
-      devdeffmt = "F32LE";
-      break;
-    case CUBEB_DEVICE_FMT_F32BE:
-      devdeffmt = "F32BE";
-      break;
-    default:
-      devdeffmt = "unknown?";
-      break;
+  case CUBEB_DEVICE_FMT_S16LE:
+    devdeffmt = "S16LE";
+    break;
+  case CUBEB_DEVICE_FMT_S16BE:
+    devdeffmt = "S16BE";
+    break;
+  case CUBEB_DEVICE_FMT_F32LE:
+    devdeffmt = "F32LE";
+    break;
+  case CUBEB_DEVICE_FMT_F32BE:
+    devdeffmt = "F32BE";
+    break;
+  default:
+    devdeffmt = "unknown?";
+    break;
   };
 
   if (device_info->format & CUBEB_DEVICE_FMT_S16LE) {
@@ -597,20 +617,17 @@ void log_device(cubeb_device_info * device_info)
       "\tRate:\t[%u, %u] (default: %u)\n"
       "\tLatency: lo %u frames, hi %u frames",
       device_info->device_id, device_info->preferred ? " (PREFERRED)" : "",
-      device_info->friendly_name,
-      device_info->group_id,
-      device_info->vendor_name,
-      devtype,
-      devstate,
-      device_info->max_channels,
-      (devfmts[0] == '\0') ? devfmts : devfmts + 1, (unsigned int)device_info->format, devdeffmt,
-      device_info->min_rate, device_info->max_rate, device_info->default_rate,
-      device_info->latency_lo, device_info->latency_hi);
+      device_info->friendly_name, device_info->group_id,
+      device_info->vendor_name, devtype, devstate, device_info->max_channels,
+      (devfmts[0] == '\0') ? devfmts : devfmts + 1,
+      (unsigned int)device_info->format, devdeffmt, device_info->min_rate,
+      device_info->max_rate, device_info->default_rate, device_info->latency_lo,
+      device_info->latency_hi);
 }
 
-int cubeb_enumerate_devices(cubeb * context,
-                            cubeb_device_type devtype,
-                            cubeb_device_collection * collection)
+int
+cubeb_enumerate_devices(cubeb * context, cubeb_device_type devtype,
+                        cubeb_device_collection * collection)
 {
   int rv;
   if ((devtype & (CUBEB_DEVICE_TYPE_INPUT | CUBEB_DEVICE_TYPE_OUTPUT)) == 0)
@@ -631,8 +648,9 @@ int cubeb_enumerate_devices(cubeb * context,
   return rv;
 }
 
-int cubeb_device_collection_destroy(cubeb * context,
-                                    cubeb_device_collection * collection)
+int
+cubeb_device_collection_destroy(cubeb * context,
+                                cubeb_device_collection * collection)
 {
   int r;
 
@@ -654,23 +672,26 @@ int cubeb_device_collection_destroy(cubeb * context,
   return r;
 }
 
-int cubeb_register_device_collection_changed(cubeb * context,
-                                             cubeb_device_type devtype,
-                                             cubeb_device_collection_changed_callback callback,
-                                             void * user_ptr)
+int
+cubeb_register_device_collection_changed(
+    cubeb * context, cubeb_device_type devtype,
+    cubeb_device_collection_changed_callback callback, void * user_ptr)
 {
-  if (context == NULL || (devtype & (CUBEB_DEVICE_TYPE_INPUT | CUBEB_DEVICE_TYPE_OUTPUT)) == 0)
+  if (context == NULL ||
+      (devtype & (CUBEB_DEVICE_TYPE_INPUT | CUBEB_DEVICE_TYPE_OUTPUT)) == 0)
     return CUBEB_ERROR_INVALID_PARAMETER;
 
   if (!context->ops->register_device_collection_changed) {
     return CUBEB_ERROR_NOT_SUPPORTED;
   }
 
-  return context->ops->register_device_collection_changed(context, devtype, callback, user_ptr);
+  return context->ops->register_device_collection_changed(context, devtype,
+                                                          callback, user_ptr);
 }
 
-int cubeb_set_log_callback(cubeb_log_level log_level,
-                           cubeb_log_callback log_callback)
+int
+cubeb_set_log_callback(cubeb_log_level log_level,
+                       cubeb_log_callback log_callback)
 {
   if (log_level < CUBEB_LOG_DISABLED || log_level > CUBEB_LOG_VERBOSE) {
     return CUBEB_ERROR_INVALID_FORMAT;
@@ -698,4 +719,3 @@ int cubeb_set_log_callback(cubeb_log_level log_level,
 
   return CUBEB_OK;
 }
-
diff --git a/src/cubeb_aaudio.cpp b/src/cubeb_aaudio.cpp
index 0ac6dd2..448ea91 100644
--- a/src/cubeb_aaudio.cpp
+++ b/src/cubeb_aaudio.cpp
@@ -997,8 +997,10 @@ aaudio_stream_init(cubeb * ctx, cubeb_stream ** stream,
   stm->user_ptr = user_ptr;
   stm->data_callback = data_callback;
   stm->state_callback = state_callback;
-  stm->voice_input = input_stream_params && !!(input_stream_params->prefs & CUBEB_STREAM_PREF_VOICE);
-  stm->voice_output = output_stream_params && !!(output_stream_params->prefs & CUBEB_STREAM_PREF_VOICE);
+  stm->voice_input = input_stream_params &&
+                     !!(input_stream_params->prefs & CUBEB_STREAM_PREF_VOICE);
+  stm->voice_output = output_stream_params &&
+                      !!(output_stream_params->prefs & CUBEB_STREAM_PREF_VOICE);
   stm->previous_clock = 0;
 
   LOG("cubeb stream prefs: voice_input: %s voice_output: %s",
diff --git a/src/cubeb_alsa.c b/src/cubeb_alsa.c
index cbed0df..4a55b02 100644
--- a/src/cubeb_alsa.c
+++ b/src/cubeb_alsa.c
@@ -8,56 +8,56 @@
 #define _DEFAULT_SOURCE
 #define _BSD_SOURCE
 #define _XOPEN_SOURCE 500
-#include <pthread.h>
-#include <sys/time.h>
+#include "cubeb-internal.h"
+#include "cubeb/cubeb.h"
+#include <alsa/asoundlib.h>
 #include <assert.h>
+#include <dlfcn.h>
 #include <limits.h>
 #include <poll.h>
+#include <pthread.h>
+#include <sys/time.h>
 #include <unistd.h>
-#include <dlfcn.h>
-#include <alsa/asoundlib.h>
-#include "cubeb/cubeb.h"
-#include "cubeb-internal.h"
 
 #ifdef DISABLE_LIBASOUND_DLOPEN
 #define WRAP(x) x
 #else
 #define WRAP(x) cubeb_##x
-#define LIBASOUND_API_VISIT(X)                   \
-  X(snd_config)                                  \
-  X(snd_config_add)                              \
-  X(snd_config_copy)                             \
-  X(snd_config_delete)                           \
-  X(snd_config_get_id)                           \
-  X(snd_config_get_string)                       \
-  X(snd_config_imake_integer)                    \
-  X(snd_config_search)                           \
-  X(snd_config_search_definition)                \
-  X(snd_lib_error_set_handler)                   \
-  X(snd_pcm_avail_update)                        \
-  X(snd_pcm_close)                               \
-  X(snd_pcm_delay)                               \
-  X(snd_pcm_drain)                               \
-  X(snd_pcm_frames_to_bytes)                     \
-  X(snd_pcm_get_params)                          \
-  X(snd_pcm_hw_params_any)                       \
-  X(snd_pcm_hw_params_get_channels_max)          \
-  X(snd_pcm_hw_params_get_rate)                  \
-  X(snd_pcm_hw_params_set_rate_near)             \
-  X(snd_pcm_hw_params_sizeof)                    \
-  X(snd_pcm_nonblock)                            \
-  X(snd_pcm_open)                                \
-  X(snd_pcm_open_lconf)                          \
-  X(snd_pcm_pause)                               \
-  X(snd_pcm_poll_descriptors)                    \
-  X(snd_pcm_poll_descriptors_count)              \
-  X(snd_pcm_poll_descriptors_revents)            \
-  X(snd_pcm_readi)                               \
-  X(snd_pcm_recover)                             \
-  X(snd_pcm_set_params)                          \
-  X(snd_pcm_start)                               \
-  X(snd_pcm_state)                               \
-  X(snd_pcm_writei)                              \
+#define LIBASOUND_API_VISIT(X)                                                 \
+  X(snd_config)                                                                \
+  X(snd_config_add)                                                            \
+  X(snd_config_copy)                                                           \
+  X(snd_config_delete)                                                         \
+  X(snd_config_get_id)                                                         \
+  X(snd_config_get_string)                                                     \
+  X(snd_config_imake_integer)                                                  \
+  X(snd_config_search)                                                         \
+  X(snd_config_search_definition)                                              \
+  X(snd_lib_error_set_handler)                                                 \
+  X(snd_pcm_avail_update)                                                      \
+  X(snd_pcm_close)                                                             \
+  X(snd_pcm_delay)                                                             \
+  X(snd_pcm_drain)                                                             \
+  X(snd_pcm_frames_to_bytes)                                                   \
+  X(snd_pcm_get_params)                                                        \
+  X(snd_pcm_hw_params_any)                                                     \
+  X(snd_pcm_hw_params_get_channels_max)                                        \
+  X(snd_pcm_hw_params_get_rate)                                                \
+  X(snd_pcm_hw_params_set_rate_near)                                           \
+  X(snd_pcm_hw_params_sizeof)                                                  \
+  X(snd_pcm_nonblock)                                                          \
+  X(snd_pcm_open)                                                              \
+  X(snd_pcm_open_lconf)                                                        \
+  X(snd_pcm_pause)                                                             \
+  X(snd_pcm_poll_descriptors)                                                  \
+  X(snd_pcm_poll_descriptors_count)                                            \
+  X(snd_pcm_poll_descriptors_revents)                                          \
+  X(snd_pcm_readi)                                                             \
+  X(snd_pcm_recover)                                                           \
+  X(snd_pcm_set_params)                                                        \
+  X(snd_pcm_start)                                                             \
+  X(snd_pcm_state)                                                             \
+  X(snd_pcm_writei)
 
 #define MAKE_TYPEDEF(x) static typeof(x) * cubeb_##x;
 LIBASOUND_API_VISIT(MAKE_TYPEDEF);
@@ -101,7 +101,8 @@ struct cubeb {
 
   int shutdown;
 
-  /* Control pipe for forcing poll to wake and rebuild fds or recalculate the timeout. */
+  /* Control pipe for forcing poll to wake and rebuild fds or recalculate the
+   * timeout. */
   int control_fd_read;
   int control_fd_write;
 
@@ -116,13 +117,7 @@ struct cubeb {
   int is_pa;
 };
 
-enum stream_state {
-  INACTIVE,
-  RUNNING,
-  DRAINING,
-  PROCESSING,
-  ERROR
-};
+enum stream_state { INACTIVE, RUNNING, DRAINING, PROCESSING, ERROR };
 
 struct cubeb_stream {
   /* Note: Must match cubeb_stream layout in cubeb.c. */
@@ -146,7 +141,8 @@ struct cubeb_stream {
   enum stream_state state;
 
   struct pollfd * saved_fds; /* A copy of the pollfds passed in at init time. */
-  struct pollfd * fds; /* Pointer to this waitable's pollfds within struct cubeb's fds. */
+  struct pollfd *
+      fds; /* Pointer to this waitable's pollfds within struct cubeb's fds. */
   nfds_t nfds;
 
   struct timeval drain_timeout;
@@ -294,8 +290,10 @@ set_timeout(struct timeval * timeout, unsigned int ms)
 static void
 stream_buffer_decrement(cubeb_stream * stm, long count)
 {
-  char * bufremains = stm->buffer + WRAP(snd_pcm_frames_to_bytes)(stm->pcm, count);
-  memmove(stm->buffer, bufremains, WRAP(snd_pcm_frames_to_bytes)(stm->pcm, stm->bufframes - count));
+  char * bufremains =
+      stm->buffer + WRAP(snd_pcm_frames_to_bytes)(stm->pcm, count);
+  memmove(stm->buffer, bufremains,
+          WRAP(snd_pcm_frames_to_bytes)(stm->pcm, stm->bufframes - count));
   stm->bufframes -= count;
 }
 
@@ -327,7 +325,8 @@ alsa_process_stream(cubeb_stream * stm)
   /* Call _poll_descriptors_revents() even if we don't use it
      to let underlying plugins clear null events.  Otherwise poll()
      may wake up again and again, producing unnecessary CPU usage. */
-  WRAP(snd_pcm_poll_descriptors_revents)(stm->pcm, stm->fds, stm->nfds, &revents);
+  WRAP(snd_pcm_poll_descriptors_revents)
+  (stm->pcm, stm->fds, stm->nfds, &revents);
 
   avail = WRAP(snd_pcm_avail_update)(stm->pcm);
 
@@ -337,8 +336,9 @@ alsa_process_stream(cubeb_stream * stm)
     return RUNNING;
   }
 
-  /* This could happen if we were suspended with SIGSTOP/Ctrl+Z for a long time. */
-  if ((unsigned int) avail > stm->buffer_size) {
+  /* This could happen if we were suspended with SIGSTOP/Ctrl+Z for a long time.
+   */
+  if ((unsigned int)avail > stm->buffer_size) {
     avail = stm->buffer_size;
   }
 
@@ -352,7 +352,7 @@ alsa_process_stream(cubeb_stream * stm)
       // TODO: should it be marked as DRAINING?
     }
 
-    got = WRAP(snd_pcm_readi)(stm->pcm, stm->buffer+stm->bufframes, avail);
+    got = WRAP(snd_pcm_readi)(stm->pcm, stm->buffer + stm->bufframes, avail);
 
     if (got < 0) {
       avail = got; // the error handler below will recover us
@@ -366,18 +366,24 @@ alsa_process_stream(cubeb_stream * stm)
 
   /* Capture: Pass read frames to callback function */
   if (stm->stream_type == SND_PCM_STREAM_CAPTURE && stm->bufframes > 0 &&
-      (!stm->other_stream || stm->other_stream->bufframes < stm->other_stream->buffer_size)) {
+      (!stm->other_stream ||
+       stm->other_stream->bufframes < stm->other_stream->buffer_size)) {
     snd_pcm_sframes_t wrote = stm->bufframes;
     struct cubeb_stream * mainstm = stm->other_stream ? stm->other_stream : stm;
-    void * other_buffer = stm->other_stream ? stm->other_stream->buffer + stm->other_stream->bufframes : NULL;
+    void * other_buffer = stm->other_stream ? stm->other_stream->buffer +
+                                                  stm->other_stream->bufframes
+                                            : NULL;
 
     /* Correct write size to the other stream available space */
-    if (stm->other_stream && wrote > (snd_pcm_sframes_t) (stm->other_stream->buffer_size - stm->other_stream->bufframes)) {
+    if (stm->other_stream &&
+        wrote > (snd_pcm_sframes_t)(stm->other_stream->buffer_size -
+                                    stm->other_stream->bufframes)) {
       wrote = stm->other_stream->buffer_size - stm->other_stream->bufframes;
     }
 
     pthread_mutex_unlock(&stm->mutex);
-    wrote = stm->data_callback(mainstm, stm->user_ptr, stm->buffer, other_buffer, wrote);
+    wrote = stm->data_callback(mainstm, stm->user_ptr, stm->buffer,
+                               other_buffer, wrote);
     pthread_mutex_lock(&stm->mutex);
 
     if (wrote < 0) {
@@ -392,14 +398,17 @@ alsa_process_stream(cubeb_stream * stm)
   }
 
   /* Playback: Don't have enough data? Let's ask for more. */
-  if (stm->stream_type == SND_PCM_STREAM_PLAYBACK && avail > (snd_pcm_sframes_t) stm->bufframes &&
+  if (stm->stream_type == SND_PCM_STREAM_PLAYBACK &&
+      avail > (snd_pcm_sframes_t)stm->bufframes &&
       (!stm->other_stream || stm->other_stream->bufframes > 0)) {
     long got = avail - stm->bufframes;
     void * other_buffer = stm->other_stream ? stm->other_stream->buffer : NULL;
-    char * buftail = stm->buffer + WRAP(snd_pcm_frames_to_bytes)(stm->pcm, stm->bufframes);
+    char * buftail =
+        stm->buffer + WRAP(snd_pcm_frames_to_bytes)(stm->pcm, stm->bufframes);
 
     /* Correct read size to the other stream available frames */
-    if (stm->other_stream && got > (snd_pcm_sframes_t) stm->other_stream->bufframes) {
+    if (stm->other_stream &&
+        got > (snd_pcm_sframes_t)stm->other_stream->bufframes) {
       got = stm->other_stream->bufframes;
     }
 
@@ -419,11 +428,13 @@ alsa_process_stream(cubeb_stream * stm)
   }
 
   /* Playback: Still don't have enough data? Add some silence. */
-  if (stm->stream_type == SND_PCM_STREAM_PLAYBACK && avail > (snd_pcm_sframes_t) stm->bufframes) {
+  if (stm->stream_type == SND_PCM_STREAM_PLAYBACK &&
+      avail > (snd_pcm_sframes_t)stm->bufframes) {
     long drain_frames = avail - stm->bufframes;
-    double drain_time = (double) drain_frames / stm->params.rate;
+    double drain_time = (double)drain_frames / stm->params.rate;
 
-    char * buftail = stm->buffer + WRAP(snd_pcm_frames_to_bytes)(stm->pcm, stm->bufframes);
+    char * buftail =
+        stm->buffer + WRAP(snd_pcm_frames_to_bytes)(stm->pcm, stm->bufframes);
     memset(buftail, 0, WRAP(snd_pcm_frames_to_bytes)(stm->pcm, drain_frames));
     stm->bufframes = avail;
 
@@ -440,12 +451,12 @@ alsa_process_stream(cubeb_stream * stm)
     snd_pcm_sframes_t wrote;
 
     if (stm->params.format == CUBEB_SAMPLE_FLOAT32NE) {
-      float * b = (float *) stm->buffer;
+      float * b = (float *)stm->buffer;
       for (uint32_t i = 0; i < avail * stm->params.channels; i++) {
         b[i] *= stm->volume;
       }
     } else {
-      short * b = (short *) stm->buffer;
+      short * b = (short *)stm->buffer;
       for (uint32_t i = 0; i < avail * stm->params.channels; i++) {
         b[i] *= stm->volume;
       }
@@ -467,8 +478,7 @@ alsa_process_stream(cubeb_stream * stm)
     avail = WRAP(snd_pcm_recover)(stm->pcm, avail, 0);
 
     /* Capture pcm must be started after initial setup/recover */
-    if (avail >= 0 &&
-        stm->stream_type == SND_PCM_STREAM_CAPTURE &&
+    if (avail >= 0 && stm->stream_type == SND_PCM_STREAM_CAPTURE &&
         WRAP(snd_pcm_state)(stm->pcm) == SND_PCM_STATE_PREPARED) {
       avail = WRAP(snd_pcm_start)(stm->pcm);
     }
@@ -533,7 +543,8 @@ alsa_run(cubeb * ctx)
       stm = ctx->streams[i];
       /* We can't use snd_pcm_poll_descriptors_revents here because of
          https://github.com/kinetiknz/cubeb/issues/135. */
-      if (stm && stm->state == RUNNING && stm->fds && any_revents(stm->fds, stm->nfds)) {
+      if (stm && stm->state == RUNNING && stm->fds &&
+          any_revents(stm->fds, stm->nfds)) {
         alsa_set_stream_state(stm, PROCESSING);
         pthread_mutex_unlock(&ctx->mutex);
         state = alsa_process_stream(stm);
@@ -548,7 +559,8 @@ alsa_run(cubeb * ctx)
         if (stm->state == DRAINING && ms_since(&stm->drain_timeout) >= 0) {
           alsa_set_stream_state(stm, INACTIVE);
           stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_DRAINED);
-        } else if (stm->state == RUNNING && ms_since(&stm->last_activity) > CUBEB_WATCHDOG_MS) {
+        } else if (stm->state == RUNNING &&
+                   ms_since(&stm->last_activity) > CUBEB_WATCHDOG_MS) {
           alsa_set_stream_state(stm, ERROR);
           stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_ERROR);
         }
@@ -593,7 +605,8 @@ get_slave_pcm_node(snd_config_t * lconf, snd_config_t * root_pcm)
 
   r = WRAP(snd_config_get_string)(slave_pcm, &string);
   if (r >= 0) {
-    r = WRAP(snd_config_search_definition)(lconf, "pcm_slave", string, &slave_def);
+    r = WRAP(snd_config_search_definition)(lconf, "pcm_slave", string,
+                                           &slave_def);
     if (r < 0) {
       return NULL;
     }
@@ -611,7 +624,7 @@ get_slave_pcm_node(snd_config_t * lconf, snd_config_t * root_pcm)
     }
 
     r = snprintf(node_name, sizeof(node_name), "pcm.%s", string);
-    if (r < 0 || r > (int) sizeof(node_name)) {
+    if (r < 0 || r > (int)sizeof(node_name)) {
       break;
     }
     r = WRAP(snd_config_search)(lconf, node_name, &pcm);
@@ -633,7 +646,8 @@ get_slave_pcm_node(snd_config_t * lconf, snd_config_t * root_pcm)
    higher than requested latency, but the plugin does not update its (and
    ALSA's) internal state to reflect that, leading to an immediate underrun
    situation.  Inspired by WINE's make_handle_underrun_config.
-   Reference: http://mailman.alsa-project.org/pipermail/alsa-devel/2012-July/05 */
+   Reference: http://mailman.alsa-project.org/pipermail/alsa-devel/2012-July/05
+ */
 static snd_config_t *
 init_local_config_with_workaround(char const * pcm_name)
 {
@@ -667,7 +681,7 @@ init_local_config_with_workaround(char const * pcm_name)
     }
 
     r = snprintf(node_name, sizeof(node_name), "pcm.%s", string);
-    if (r < 0 || r > (int) sizeof(node_name)) {
+    if (r < 0 || r > (int)sizeof(node_name)) {
       break;
     }
     r = WRAP(snd_config_search)(lconf, node_name, &pcm_node);
@@ -675,12 +689,14 @@ init_local_config_with_workaround(char const * pcm_name)
       break;
     }
 
-    /* If this PCM has a slave, walk the slave configurations until we reach the bottom. */
+    /* If this PCM has a slave, walk the slave configurations until we reach the
+     * bottom. */
     while ((node = get_slave_pcm_node(lconf, pcm_node)) != NULL) {
       pcm_node = node;
     }
 
-    /* Fetch the PCM node's type, and bail out if it's not the PulseAudio plugin. */
+    /* Fetch the PCM node's type, and bail out if it's not the PulseAudio
+     * plugin. */
     r = WRAP(snd_config_search)(pcm_node, "type", &node);
     if (r < 0) {
       break;
@@ -722,13 +738,15 @@ init_local_config_with_workaround(char const * pcm_name)
 }
 
 static int
-alsa_locked_pcm_open(snd_pcm_t ** pcm, char const * pcm_name, snd_pcm_stream_t stream, snd_config_t * local_config)
+alsa_locked_pcm_open(snd_pcm_t ** pcm, char const * pcm_name,
+                     snd_pcm_stream_t stream, snd_config_t * local_config)
 {
   int r;
 
   pthread_mutex_lock(&cubeb_alsa_mutex);
   if (local_config) {
-    r = WRAP(snd_pcm_open_lconf)(pcm, pcm_name, stream, SND_PCM_NONBLOCK, local_config);
+    r = WRAP(snd_pcm_open_lconf)(pcm, pcm_name, stream, SND_PCM_NONBLOCK,
+                                 local_config);
   } else {
     r = WRAP(snd_pcm_open)(pcm, pcm_name, stream, SND_PCM_NONBLOCK);
   }
@@ -819,12 +837,13 @@ alsa_init(cubeb ** context, char const * context_name)
     }
   }
 
-#define LOAD(x) {                               \
-    cubeb_##x = dlsym(libasound, #x);            \
-    if (!cubeb_##x) {                           \
-      dlclose(libasound);                        \
-      return CUBEB_ERROR;                       \
-    }                                           \
+#define LOAD(x)                                                                \
+  {                                                                            \
+    cubeb_##x = dlsym(libasound, #x);                                          \
+    if (!cubeb_##x) {                                                          \
+      dlclose(libasound);                                                      \
+      return CUBEB_ERROR;                                                      \
+    }                                                                          \
   }
 
   LIBASOUND_API_VISIT(LOAD);
@@ -876,7 +895,8 @@ alsa_init(cubeb ** context, char const * context_name)
 
   /* Open a dummy PCM to force the configuration space to be evaluated so that
      init_local_config_with_workaround can find and modify the default node. */
-  r = alsa_locked_pcm_open(&dummy, CUBEB_ALSA_PCM_NAME, SND_PCM_STREAM_PLAYBACK, NULL);
+  r = alsa_locked_pcm_open(&dummy, CUBEB_ALSA_PCM_NAME, SND_PCM_STREAM_PLAYBACK,
+                           NULL);
   if (r >= 0) {
     alsa_locked_pcm_close(dummy);
   }
@@ -886,7 +906,8 @@ alsa_init(cubeb ** context, char const * context_name)
   pthread_mutex_unlock(&cubeb_alsa_mutex);
   if (ctx->local_config) {
     ctx->is_pa = 1;
-    r = alsa_locked_pcm_open(&dummy, CUBEB_ALSA_PCM_NAME, SND_PCM_STREAM_PLAYBACK, ctx->local_config);
+    r = alsa_locked_pcm_open(&dummy, CUBEB_ALSA_PCM_NAME,
+                             SND_PCM_STREAM_PLAYBACK, ctx->local_config);
     /* If we got a local_config, we found a PA PCM.  If opening a PCM with that
        config fails with EINVAL, the PA PCM is too old for this workaround. */
     if (r == -EINVAL) {
@@ -944,17 +965,17 @@ alsa_destroy(cubeb * ctx)
   free(ctx);
 }
 
-static void alsa_stream_destroy(cubeb_stream * stm);
+static void
+alsa_stream_destroy(cubeb_stream * stm);
 
 static int
-alsa_stream_init_single(cubeb * ctx, cubeb_stream ** stream, char const * stream_name,
-                        snd_pcm_stream_t stream_type,
+alsa_stream_init_single(cubeb * ctx, cubeb_stream ** stream,
+                        char const * stream_name, snd_pcm_stream_t stream_type,
                         cubeb_devid deviceid,
                         cubeb_stream_params * stream_params,
                         unsigned int latency_frames,
                         cubeb_data_callback data_callback,
-                        cubeb_state_callback state_callback,
-                        void * user_ptr)
+                        cubeb_state_callback state_callback, void * user_ptr)
 {
   (void)stream_name;
   cubeb_stream * stm;
@@ -962,7 +983,8 @@ alsa_stream_init_single(cubeb * ctx, cubeb_stream ** stream, char const * stream
   snd_pcm_format_t format;
   snd_pcm_uframes_t period_size;
   int latency_us = 0;
-  char const * pcm_name = deviceid ? (char const *) deviceid : CUBEB_ALSA_PCM_NAME;
+  char const * pcm_name =
+      deviceid ? (char const *)deviceid : CUBEB_ALSA_PCM_NAME;
 
   assert(ctx && stream);
 
@@ -1018,7 +1040,8 @@ alsa_stream_init_single(cubeb * ctx, cubeb_stream ** stream, char const * stream
   r = pthread_cond_init(&stm->cond, NULL);
   assert(r == 0);
 
-  r = alsa_locked_pcm_open(&stm->pcm, pcm_name, stm->stream_type, ctx->local_config);
+  r = alsa_locked_pcm_open(&stm->pcm, pcm_name, stm->stream_type,
+                           ctx->local_config);
   if (r < 0) {
     alsa_stream_destroy(stm);
     return CUBEB_ERROR;
@@ -1034,12 +1057,12 @@ alsa_stream_init_single(cubeb * ctx, cubeb_stream ** stream, char const * stream
      Only resort to this hack if the handle_underrun workaround failed. */
   if (!ctx->local_config && ctx->is_pa) {
     const int min_latency = 5e5;
-    latency_us = latency_us < min_latency ? min_latency: latency_us;
+    latency_us = latency_us < min_latency ? min_latency : latency_us;
   }
 
   r = WRAP(snd_pcm_set_params)(stm->pcm, format, SND_PCM_ACCESS_RW_INTERLEAVED,
-                         stm->params.channels, stm->params.rate, 1,
-                         latency_us);
+                               stm->params.channels, stm->params.rate, 1,
+                               latency_us);
   if (r < 0) {
     alsa_stream_destroy(stm);
     return CUBEB_ERROR_INVALID_FORMAT;
@@ -1048,9 +1071,11 @@ alsa_stream_init_single(cubeb * ctx, cubeb_stream ** stream, char const * stream
   r = WRAP(snd_pcm_get_params)(stm->pcm, &stm->buffer_size, &period_size);
   assert(r == 0);
 
-  /* Double internal buffer size to have enough space when waiting for the other side of duplex connection */
+  /* Double internal buffer size to have enough space when waiting for the other
+   * side of duplex connection */
   stm->buffer_size *= 2;
-  stm->buffer = calloc(1, WRAP(snd_pcm_frames_to_bytes)(stm->pcm, stm->buffer_size));
+  stm->buffer =
+      calloc(1, WRAP(snd_pcm_frames_to_bytes)(stm->pcm, stm->buffer_size));
   assert(stm->buffer);
 
   stm->nfds = WRAP(snd_pcm_poll_descriptors_count)(stm->pcm);
@@ -1059,7 +1084,7 @@ alsa_stream_init_single(cubeb * ctx, cubeb_stream ** stream, char const * stream
   stm->saved_fds = calloc(stm->nfds, sizeof(struct pollfd));
   assert(stm->saved_fds);
   r = WRAP(snd_pcm_poll_descriptors)(stm->pcm, stm->saved_fds, stm->nfds);
-  assert((nfds_t) r == stm->nfds);
+  assert((nfds_t)r == stm->nfds);
 
   if (alsa_register_stream(ctx, stm) != 0) {
     alsa_stream_destroy(stm);
@@ -1077,22 +1102,23 @@ alsa_stream_init(cubeb * ctx, cubeb_stream ** stream, char const * stream_name,
                  cubeb_stream_params * input_stream_params,
                  cubeb_devid output_device,
                  cubeb_stream_params * output_stream_params,
-                 unsigned int latency_frames,
-                 cubeb_data_callback data_callback, cubeb_state_callback state_callback,
-                 void * user_ptr)
+                 unsigned int latency_frames, cubeb_data_callback data_callback,
+                 cubeb_state_callback state_callback, void * user_ptr)
 {
   int result = CUBEB_OK;
-  cubeb_stream * instm = NULL, * outstm = NULL;
+  cubeb_stream *instm = NULL, *outstm = NULL;
 
   if (result == CUBEB_OK && input_stream_params) {
-    result = alsa_stream_init_single(ctx, &instm, stream_name, SND_PCM_STREAM_CAPTURE,
-                                     input_device, input_stream_params, latency_frames,
+    result = alsa_stream_init_single(ctx, &instm, stream_name,
+                                     SND_PCM_STREAM_CAPTURE, input_device,
+                                     input_stream_params, latency_frames,
                                      data_callback, state_callback, user_ptr);
   }
 
   if (result == CUBEB_OK && output_stream_params) {
-    result = alsa_stream_init_single(ctx, &outstm, stream_name, SND_PCM_STREAM_PLAYBACK,
-                                     output_device, output_stream_params, latency_frames,
+    result = alsa_stream_init_single(ctx, &outstm, stream_name,
+                                     SND_PCM_STREAM_PLAYBACK, output_device,
+                                     output_stream_params, latency_frames,
                                      data_callback, state_callback, user_ptr);
   }
 
@@ -1116,8 +1142,7 @@ alsa_stream_destroy(cubeb_stream * stm)
   int r;
   cubeb * ctx;
 
-  assert(stm && (stm->state == INACTIVE ||
-                 stm->state == ERROR ||
+  assert(stm && (stm->state == INACTIVE || stm->state == ERROR ||
                  stm->state == DRAINING));
 
   ctx = stm->context;
@@ -1159,7 +1184,7 @@ alsa_get_max_channel_count(cubeb * ctx, uint32_t * max_channels)
 {
   int r;
   cubeb_stream * stm;
-  snd_pcm_hw_params_t* hw_params;
+  snd_pcm_hw_params_t * hw_params;
   cubeb_stream_params params;
   params.rate = 44100;
   params.format = CUBEB_SAMPLE_FLOAT32NE;
@@ -1169,7 +1194,8 @@ alsa_get_max_channel_count(cubeb * ctx, uint32_t * max_channels)
 
   assert(ctx);
 
-  r = alsa_stream_init(ctx, &stm, "", NULL, NULL, NULL, &params, 100, NULL, NULL, NULL);
+  r = alsa_stream_init(ctx, &stm, "", NULL, NULL, NULL, &params, 100, NULL,
+                       NULL, NULL);
   if (r != CUBEB_OK) {
     return CUBEB_ERROR;
   }
@@ -1192,7 +1218,8 @@ alsa_get_max_channel_count(cubeb * ctx, uint32_t * max_channels)
 }
 
 static int
-alsa_get_preferred_sample_rate(cubeb * ctx, uint32_t * rate) {
+alsa_get_preferred_sample_rate(cubeb * ctx, uint32_t * rate)
+{
   (void)ctx;
   int r, dir;
   snd_pcm_t * pcm;
@@ -1202,7 +1229,8 @@ alsa_get_preferred_sample_rate(cubeb * ctx, uint32_t * rate) {
 
   /* get a pcm, disabling resampling, so we get a rate the
    * hardware/dmix/pulse/etc. supports. */
-  r = WRAP(snd_pcm_open)(&pcm, CUBEB_ALSA_PCM_NAME, SND_PCM_STREAM_PLAYBACK, SND_PCM_NO_AUTO_RESAMPLE);
+  r = WRAP(snd_pcm_open)(&pcm, CUBEB_ALSA_PCM_NAME, SND_PCM_STREAM_PLAYBACK,
+                         SND_PCM_NO_AUTO_RESAMPLE);
   if (r < 0) {
     return CUBEB_ERROR;
   }
@@ -1235,7 +1263,8 @@ alsa_get_preferred_sample_rate(cubeb * ctx, uint32_t * rate) {
 }
 
 static int
-alsa_get_min_latency(cubeb * ctx, cubeb_stream_params params, uint32_t * latency_frames)
+alsa_get_min_latency(cubeb * ctx, cubeb_stream_params params,
+                     uint32_t * latency_frames)
 {
   (void)ctx;
   /* 40ms is found to be an acceptable minimum, even on a super low-end
@@ -1331,7 +1360,7 @@ alsa_stream_get_position(cubeb_stream * stm, uint64_t * position)
   assert(delay >= 0);
 
   *position = 0;
-  if (stm->stream_position >= (snd_pcm_uframes_t) delay) {
+  if (stm->stream_position >= (snd_pcm_uframes_t)delay) {
     *position = stm->stream_position - delay;
   }
 
@@ -1346,7 +1375,8 @@ alsa_stream_get_latency(cubeb_stream * stm, uint32_t * latency)
 {
   snd_pcm_sframes_t delay;
   /* This function returns the delay in frames until a frame written using
-     snd_pcm_writei is sent to the DAC. The DAC delay should be < 1ms anyways. */
+     snd_pcm_writei is sent to the DAC. The DAC delay should be < 1ms anyways.
+   */
   if (WRAP(snd_pcm_delay)(stm->pcm, &delay)) {
     return CUBEB_ERROR;
   }
@@ -1371,7 +1401,7 @@ static int
 alsa_enumerate_devices(cubeb * context, cubeb_device_type type,
                        cubeb_device_collection * collection)
 {
-  cubeb_device_info* device = NULL;
+  cubeb_device_info * device = NULL;
 
   if (!context)
     return CUBEB_ERROR;
@@ -1390,13 +1420,13 @@ alsa_enumerate_devices(cubeb * context, cubeb_device_type type,
   }
 
   char const * a_name = "default";
-  device = (cubeb_device_info *) calloc(1, sizeof(cubeb_device_info));
+  device = (cubeb_device_info *)calloc(1, sizeof(cubeb_device_info));
   assert(device);
   if (!device)
     return CUBEB_ERROR;
 
   device->device_id = a_name;
-  device->devid = (cubeb_devid) device->device_id;
+  device->devid = (cubeb_devid)device->device_id;
   device->friendly_name = a_name;
   device->group_id = a_name;
   device->vendor_name = a_name;
@@ -1423,31 +1453,30 @@ alsa_device_collection_destroy(cubeb * context,
                                cubeb_device_collection * collection)
 {
   assert(collection->count == 1);
-  (void) context;
+  (void)context;
   free(collection->device);
   return CUBEB_OK;
 }
 
 static struct cubeb_ops const alsa_ops = {
-  .init = alsa_init,
-  .get_backend_id = alsa_get_backend_id,
-  .get_max_channel_count = alsa_get_max_channel_count,
-  .get_min_latency = alsa_get_min_latency,
-  .get_preferred_sample_rate = alsa_get_preferred_sample_rate,
-  .enumerate_devices = alsa_enumerate_devices,
-  .device_collection_destroy = alsa_device_collection_destroy,
-  .destroy = alsa_destroy,
-  .stream_init = alsa_stream_init,
-  .stream_destroy = alsa_stream_destroy,
-  .stream_start = alsa_stream_start,
-  .stream_stop = alsa_stream_stop,
-  .stream_get_position = alsa_stream_get_position,
-  .stream_get_latency = alsa_stream_get_latency,
-  .stream_get_input_latency = NULL,
-  .stream_set_volume = alsa_stream_set_volume,
-  .stream_set_name = NULL,
-  .stream_get_current_device = NULL,
-  .stream_device_destroy = NULL,
-  .stream_register_device_changed_callback = NULL,
-  .register_device_collection_changed = NULL
-};
+    .init = alsa_init,
+    .get_backend_id = alsa_get_backend_id,
+    .get_max_channel_count = alsa_get_max_channel_count,
+    .get_min_latency = alsa_get_min_latency,
+    .get_preferred_sample_rate = alsa_get_preferred_sample_rate,
+    .enumerate_devices = alsa_enumerate_devices,
+    .device_collection_destroy = alsa_device_collection_destroy,
+    .destroy = alsa_destroy,
+    .stream_init = alsa_stream_init,
+    .stream_destroy = alsa_stream_destroy,
+    .stream_start = alsa_stream_start,
+    .stream_stop = alsa_stream_stop,
+    .stream_get_position = alsa_stream_get_position,
+    .stream_get_latency = alsa_stream_get_latency,
+    .stream_get_input_latency = NULL,
+    .stream_set_volume = alsa_stream_set_volume,
+    .stream_set_name = NULL,
+    .stream_get_current_device = NULL,
+    .stream_device_destroy = NULL,
+    .stream_register_device_changed_callback = NULL,
+    .register_device_collection_changed = NULL};
diff --git a/src/cubeb_array_queue.h b/src/cubeb_array_queue.h
index a8ea4cd..d6d9581 100644
--- a/src/cubeb_array_queue.h
+++ b/src/cubeb_array_queue.h
@@ -16,8 +16,7 @@
 extern "C" {
 #endif
 
-typedef struct
-{
+typedef struct {
   void ** buf;
   size_t num;
   size_t writePos;
@@ -25,10 +24,11 @@ typedef struct
   pthread_mutex_t mutex;
 } array_queue;
 
-array_queue * array_queue_create(size_t num)
+array_queue *
+array_queue_create(size_t num)
 {
   assert(num != 0);
-  array_queue * new_queue = (array_queue*)calloc(1, sizeof(array_queue));
+  array_queue * new_queue = (array_queue *)calloc(1, sizeof(array_queue));
   new_queue->buf = (void **)calloc(1, sizeof(void *) * num);
   new_queue->readPos = 0;
   new_queue->writePos = 0;
@@ -39,7 +39,8 @@ array_queue * array_queue_create(size_t num)
   return new_queue;
 }
 
-void array_queue_destroy(array_queue * aq)
+void
+array_queue_destroy(array_queue * aq)
 {
   assert(aq);
 
@@ -48,14 +49,14 @@ void array_queue_destroy(array_queue * aq)
   free(aq);
 }
 
-int array_queue_push(array_queue * aq, void * item)
+int
+array_queue_push(array_queue * aq, void * item)
 {
   assert(item);
 
   pthread_mutex_lock(&aq->mutex);
   int ret = -1;
-  if(aq->buf[aq->writePos % aq->num] == NULL)
-  {
+  if (aq->buf[aq->writePos % aq->num] == NULL) {
     aq->buf[aq->writePos % aq->num] = item;
     aq->writePos = (aq->writePos + 1) % aq->num;
     ret = 0;
@@ -65,12 +66,12 @@ int array_queue_push(array_queue * aq, void * item)
   return ret;
 }
 
-void* array_queue_pop(array_queue * aq)
+void *
+array_queue_pop(array_queue * aq)
 {
   pthread_mutex_lock(&aq->mutex);
   void * value = aq->buf[aq->readPos % aq->num];
-  if(value)
-  {
+  if (value) {
     aq->buf[aq->readPos % aq->num] = NULL;
     aq->readPos = (aq->readPos + 1) % aq->num;
   }
@@ -78,7 +79,8 @@ void* array_queue_pop(array_queue * aq)
   return value;
 }
 
-size_t array_queue_get_size(array_queue * aq)
+size_t
+array_queue_get_size(array_queue * aq)
 {
   pthread_mutex_lock(&aq->mutex);
   ssize_t r = aq->writePos - aq->readPos;
@@ -94,4 +96,4 @@ size_t array_queue_get_size(array_queue * aq)
 }
 #endif
 
-#endif //CUBE_ARRAY_QUEUE_H
+#endif // CUBE_ARRAY_QUEUE_H
diff --git a/src/cubeb_assert.h b/src/cubeb_assert.h
index 9257a2c..d81a1ea 100644
--- a/src/cubeb_assert.h
+++ b/src/cubeb_assert.h
@@ -16,7 +16,8 @@
  * export a function or macro called XASSERT that aborts the program.
  */
 
-#define XASSERT(expr) do {                                                     \
+#define XASSERT(expr)                                                          \
+  do {                                                                         \
     if (!(expr)) {                                                             \
       fprintf(stderr, "%s:%d - fatal error: %s\n", __FILE__, __LINE__, #expr); \
       abort();                                                                 \
diff --git a/src/cubeb_audiotrack.c b/src/cubeb_audiotrack.c
index 6c7e176..59deba1 100644
--- a/src/cubeb_audiotrack.c
+++ b/src/cubeb_audiotrack.c
@@ -8,20 +8,21 @@
 #if !defined(NDEBUG)
 #define NDEBUG
 #endif
+#include <android/log.h>
 #include <assert.h>
+#include <dlfcn.h>
 #include <pthread.h>
 #include <stdlib.h>
 #include <time.h>
-#include <dlfcn.h>
-#include <android/log.h>
 
-#include "cubeb/cubeb.h"
-#include "cubeb-internal.h"
 #include "android/audiotrack_definitions.h"
+#include "cubeb-internal.h"
+#include "cubeb/cubeb.h"
 
 #ifndef ALOG
 #if defined(DEBUG) || defined(FORCE_ALOG)
-#define ALOG(args...)  __android_log_print(ANDROID_LOG_INFO, "Gecko - Cubeb" , ## args)
+#define ALOG(args...)                                                          \
+  __android_log_print(ANDROID_LOG_INFO, "Gecko - Cubeb", ##args)
 #else
 #define ALOG(args...)
 #endif
@@ -35,37 +36,44 @@
  * call dlsym to get the symbol |mangled_name|, handle the error and store the
  * pointer in |pointer|. Because depending on Android version, we want different
  * symbols, not finding a symbol is not an error. */
-#define DLSYM_DLERROR(mangled_name, pointer, lib)                       \
-  do {                                                                  \
-    pointer = dlsym(lib, mangled_name);                                 \
-    if (!pointer) {                                                     \
-      ALOG("error while loading %stm: %stm\n", mangled_name, dlerror()); \
-    } else {                                                            \
-      ALOG("%stm: OK", mangled_name);                                   \
-    }                                                                   \
-  } while(0);
+#define DLSYM_DLERROR(mangled_name, pointer, lib)                              \
+  do {                                                                         \
+    pointer = dlsym(lib, mangled_name);                                        \
+    if (!pointer) {                                                            \
+      ALOG("error while loading %stm: %stm\n", mangled_name, dlerror());       \
+    } else {                                                                   \
+      ALOG("%stm: OK", mangled_name);                                          \
+    }                                                                          \
+  } while (0);
 
 static struct cubeb_ops const audiotrack_ops;
-void audiotrack_destroy(cubeb * context);
-void audiotrack_stream_destroy(cubeb_stream * stream);
+void
+audiotrack_destroy(cubeb * context);
+void
+audiotrack_stream_destroy(cubeb_stream * stream);
 
 struct AudioTrack {
-  /* only available on ICS and later. The second int paramter is in fact of type audio_stream_type_t. */
-  /* static */ status_t (*get_min_frame_count)(int* frame_count, int stream_type, uint32_t rate);
+  /* only available on ICS and later. The second int paramter is in fact of type
+   * audio_stream_type_t. */
+  /* static */ status_t (*get_min_frame_count)(int * frame_count,
+                                               int stream_type, uint32_t rate);
   /* if we have a recent ctor, but can't find the above symbol, we
    * can get the minimum frame count with this signature, and we are
    * running gingerbread. */
-  /* static */ status_t (*get_min_frame_count_gingerbread)(int* frame_count, int stream_type, uint32_t rate);
-  void* (*ctor)(void* instance, int, unsigned int, int, int, int, unsigned int, void (*)(int, void*, void*), void*, int, int);
-  void* (*dtor)(void* instance);
-  void (*start)(void* instance);
-  void (*pause)(void* instance);
-  uint32_t (*latency)(void* instance);
-  status_t (*check)(void* instance);
-  status_t (*get_position)(void* instance, uint32_t* position);
-  /* static */ int (*get_output_samplingrate)(int* samplerate, int stream);
-  status_t (*set_marker_position)(void* instance, unsigned int);
-  status_t (*set_volume)(void* instance, float left, float right);
+  /* static */ status_t (*get_min_frame_count_gingerbread)(int * frame_count,
+                                                           int stream_type,
+                                                           uint32_t rate);
+  void * (*ctor)(void * instance, int, unsigned int, int, int, int,
+                 unsigned int, void (*)(int, void *, void *), void *, int, int);
+  void * (*dtor)(void * instance);
+  void (*start)(void * instance);
+  void (*pause)(void * instance);
+  uint32_t (*latency)(void * instance);
+  status_t (*check)(void * instance);
+  status_t (*get_position)(void * instance, uint32_t * position);
+  /* static */ int (*get_output_samplingrate)(int * samplerate, int stream);
+  status_t (*set_marker_position)(void * instance, unsigned int);
+  status_t (*set_volume)(void * instance, float left, float right);
 };
 
 struct cubeb {
@@ -89,19 +97,20 @@ struct cubeb_stream {
 };
 
 static void
-audiotrack_refill(int event, void* user, void* info)
+audiotrack_refill(int event, void * user, void * info)
 {
   cubeb_stream * stream = user;
   switch (event) {
   case EVENT_MORE_DATA: {
     long got = 0;
-    struct Buffer * b = (struct Buffer*)info;
+    struct Buffer * b = (struct Buffer *)info;
 
     if (stream->draining) {
       return;
     }
 
-    got = stream->data_callback(stream, stream->user_ptr, NULL, b->raw, b->frameCount);
+    got = stream->data_callback(stream, stream->user_ptr, NULL, b->raw,
+                                b->frameCount);
 
     stream->written += got;
 
@@ -109,7 +118,8 @@ audiotrack_refill(int event, void* user, void* info)
       stream->draining = 1;
       /* set a marker so we are notified when the are done draining, that is,
        * when every frame has been played by android. */
-      stream->context->klass.set_marker_position(stream->instance, stream->written);
+      stream->context->klass.set_marker_position(stream->instance,
+                                                 stream->written);
     }
 
     break;
@@ -125,7 +135,9 @@ audiotrack_refill(int event, void* user, void* info)
     stream->state_callback(stream, stream->user_ptr, CUBEB_STATE_DRAINED);
     break;
   case EVENT_NEW_POS:
-    assert(0 && "We don't support the setPositionUpdatePeriod feature of audiotrack.");
+    assert(
+        0 &&
+        "We don't support the setPositionUpdatePeriod feature of audiotrack.");
     break;
   case EVENT_BUFFER_END:
     assert(0 && "Should not happen.");
@@ -142,14 +154,17 @@ audiotrack_version_is_gingerbread(cubeb * ctx)
 }
 
 int
-audiotrack_get_min_frame_count(cubeb * ctx, cubeb_stream_params * params, int * min_frame_count)
+audiotrack_get_min_frame_count(cubeb * ctx, cubeb_stream_params * params,
+                               int * min_frame_count)
 {
   status_t status;
   /* Recent Android have a getMinFrameCount method. */
   if (!audiotrack_version_is_gingerbread(ctx)) {
-    status = ctx->klass.get_min_frame_count(min_frame_count, AUDIO_STREAM_TYPE_MUSIC, params->rate);
+    status = ctx->klass.get_min_frame_count(
+        min_frame_count, AUDIO_STREAM_TYPE_MUSIC, params->rate);
   } else {
-    status = ctx->klass.get_min_frame_count_gingerbread(min_frame_count, AUDIO_STREAM_TYPE_MUSIC, params->rate);
+    status = ctx->klass.get_min_frame_count_gingerbread(
+        min_frame_count, AUDIO_STREAM_TYPE_MUSIC, params->rate);
   }
   if (status != 0) {
     ALOG("error getting the min frame count");
@@ -162,7 +177,7 @@ int
 audiotrack_init(cubeb ** context, char const * context_name)
 {
   cubeb * ctx;
-  struct AudioTrack* c;
+  struct AudioTrack * c;
 
   assert(context);
   *context = NULL;
@@ -182,34 +197,45 @@ audiotrack_init(cubeb ** context, char const * context_name)
   }
 
   /* Recent Android first, then Gingerbread. */
-  DLSYM_DLERROR("_ZN7android10AudioTrackC1EijiiijPFviPvS1_ES1_ii", ctx->klass.ctor, ctx->library);
+  DLSYM_DLERROR("_ZN7android10AudioTrackC1EijiiijPFviPvS1_ES1_ii",
+                ctx->klass.ctor, ctx->library);
   DLSYM_DLERROR("_ZN7android10AudioTrackD1Ev", ctx->klass.dtor, ctx->library);
 
-  DLSYM_DLERROR("_ZNK7android10AudioTrack7latencyEv", ctx->klass.latency, ctx->library);
-  DLSYM_DLERROR("_ZNK7android10AudioTrack9initCheckEv", ctx->klass.check, ctx->library);
+  DLSYM_DLERROR("_ZNK7android10AudioTrack7latencyEv", ctx->klass.latency,
+                ctx->library);
+  DLSYM_DLERROR("_ZNK7android10AudioTrack9initCheckEv", ctx->klass.check,
+                ctx->library);
 
-  DLSYM_DLERROR("_ZN7android11AudioSystem21getOutputSamplingRateEPii", ctx->klass.get_output_samplingrate, ctx->library);
+  DLSYM_DLERROR("_ZN7android11AudioSystem21getOutputSamplingRateEPii",
+                ctx->klass.get_output_samplingrate, ctx->library);
 
-  /* |getMinFrameCount| is available on gingerbread and ICS with different signatures. */
-  DLSYM_DLERROR("_ZN7android10AudioTrack16getMinFrameCountEPi19audio_stream_type_tj", ctx->klass.get_min_frame_count, ctx->library);
+  /* |getMinFrameCount| is available on gingerbread and ICS with different
+   * signatures. */
+  DLSYM_DLERROR(
+      "_ZN7android10AudioTrack16getMinFrameCountEPi19audio_stream_type_tj",
+      ctx->klass.get_min_frame_count, ctx->library);
   if (!ctx->klass.get_min_frame_count) {
-    DLSYM_DLERROR("_ZN7android10AudioTrack16getMinFrameCountEPiij", ctx->klass.get_min_frame_count_gingerbread, ctx->library);
+    DLSYM_DLERROR("_ZN7android10AudioTrack16getMinFrameCountEPiij",
+                  ctx->klass.get_min_frame_count_gingerbread, ctx->library);
   }
 
-  DLSYM_DLERROR("_ZN7android10AudioTrack5startEv", ctx->klass.start, ctx->library);
-  DLSYM_DLERROR("_ZN7android10AudioTrack5pauseEv", ctx->klass.pause, ctx->library);
-  DLSYM_DLERROR("_ZN7android10AudioTrack11getPositionEPj", ctx->klass.get_position, ctx->library);
-  DLSYM_DLERROR("_ZN7android10AudioTrack17setMarkerPositionEj", ctx->klass.set_marker_position, ctx->library);
-  DLSYM_DLERROR("_ZN7android10AudioTrack9setVolumeEff", ctx->klass.set_volume, ctx->library);
+  DLSYM_DLERROR("_ZN7android10AudioTrack5startEv", ctx->klass.start,
+                ctx->library);
+  DLSYM_DLERROR("_ZN7android10AudioTrack5pauseEv", ctx->klass.pause,
+                ctx->library);
+  DLSYM_DLERROR("_ZN7android10AudioTrack11getPositionEPj",
+                ctx->klass.get_position, ctx->library);
+  DLSYM_DLERROR("_ZN7android10AudioTrack17setMarkerPositionEj",
+                ctx->klass.set_marker_position, ctx->library);
+  DLSYM_DLERROR("_ZN7android10AudioTrack9setVolumeEff", ctx->klass.set_volume,
+                ctx->library);
 
   /* check that we have a combination of symbol that makes sense */
   c = &ctx->klass;
-  if(!(c->ctor &&
-       c->dtor && c->latency && c->check &&
-       /* at least one way to get the minimum frame count to request. */
-       (c->get_min_frame_count ||
-        c->get_min_frame_count_gingerbread) &&
-       c->start && c->pause && c->get_position && c->set_marker_position)) {
+  if (!(c->ctor && c->dtor && c->latency && c->check &&
+        /* at least one way to get the minimum frame count to request. */
+        (c->get_min_frame_count || c->get_min_frame_count_gingerbread) &&
+        c->start && c->pause && c->get_position && c->set_marker_position)) {
     ALOG("Could not find all the symbols we need.");
     audiotrack_destroy(ctx);
     return CUBEB_ERROR;
@@ -234,14 +260,16 @@ audiotrack_get_max_channel_count(cubeb * ctx, uint32_t * max_channels)
   assert(ctx && max_channels);
 
   /* The android mixer handles up to two channels, see
-     http://androidxref.com/4.2.2_r1/xref/frameworks/av/services/audioflinger/AudioFlinger.h#67 */
+     http://androidxref.com/4.2.2_r1/xref/frameworks/av/services/audioflinger/AudioFlinger.h#67
+   */
   *max_channels = 2;
 
   return CUBEB_OK;
 }
 
 static int
-audiotrack_get_min_latency(cubeb * ctx, cubeb_stream_params params, uint32_t * latency_ms)
+audiotrack_get_min_latency(cubeb * ctx, cubeb_stream_params params,
+                           uint32_t * latency_ms)
 {
   /* We always use the lowest latency possible when using this backend (see
    * audiotrack_stream_init), so this value is not going to be used. */
@@ -276,15 +304,13 @@ audiotrack_destroy(cubeb * context)
 }
 
 int
-audiotrack_stream_init(cubeb * ctx, cubeb_stream ** stream, char const * stream_name,
-                       cubeb_devid input_device,
+audiotrack_stream_init(cubeb * ctx, cubeb_stream ** stream,
+                       char const * stream_name, cubeb_devid input_device,
                        cubeb_stream_params * input_stream_params,
                        cubeb_devid output_device,
                        cubeb_stream_params * output_stream_params,
-                       unsigned int latency,
-                       cubeb_data_callback data_callback,
-                       cubeb_state_callback state_callback,
-                       void * user_ptr)
+                       unsigned int latency, cubeb_data_callback data_callback,
+                       cubeb_state_callback state_callback, void * user_ptr)
 {
   cubeb_stream * stm;
   int32_t channels;
@@ -303,7 +329,8 @@ audiotrack_stream_init(cubeb * ctx, cubeb_stream ** stream, char const * stream_
     return CUBEB_ERROR_INVALID_FORMAT;
   }
 
-  if (audiotrack_get_min_frame_count(ctx, output_stream_params, (int *)&min_frame_count)) {
+  if (audiotrack_get_min_frame_count(ctx, output_stream_params,
+                                     (int *)&min_frame_count)) {
     return CUBEB_ERROR;
   }
 
@@ -317,21 +344,25 @@ audiotrack_stream_init(cubeb * ctx, cubeb_stream ** stream, char const * stream_
   stm->params = *output_stream_params;
 
   stm->instance = calloc(SIZE_AUDIOTRACK_INSTANCE, 1);
-  (*(uint32_t*)((intptr_t)stm->instance + SIZE_AUDIOTRACK_INSTANCE - 4)) = 0xbaadbaad;
+  (*(uint32_t *)((intptr_t)stm->instance + SIZE_AUDIOTRACK_INSTANCE - 4)) =
+      0xbaadbaad;
   assert(stm->instance && "cubeb: EOM");
 
   /* gingerbread uses old channel layout enum */
   if (audiotrack_version_is_gingerbread(ctx)) {
-    channels = stm->params.channels == 2 ? AUDIO_CHANNEL_OUT_STEREO_Legacy : AUDIO_CHANNEL_OUT_MONO_Legacy;
+    channels = stm->params.channels == 2 ? AUDIO_CHANNEL_OUT_STEREO_Legacy
+                                         : AUDIO_CHANNEL_OUT_MONO_Legacy;
   } else {
-    channels = stm->params.channels == 2 ? AUDIO_CHANNEL_OUT_STEREO_ICS : AUDIO_CHANNEL_OUT_MONO_ICS;
+    channels = stm->params.channels == 2 ? AUDIO_CHANNEL_OUT_STEREO_ICS
+                                         : AUDIO_CHANNEL_OUT_MONO_ICS;
   }
 
   ctx->klass.ctor(stm->instance, AUDIO_STREAM_TYPE_MUSIC, stm->params.rate,
                   AUDIO_FORMAT_PCM_16_BIT, channels, min_frame_count, 0,
                   audiotrack_refill, stm, 0, 0);
 
-  assert((*(uint32_t*)((intptr_t)stm->instance + SIZE_AUDIOTRACK_INSTANCE - 4)) == 0xbaadbaad);
+  assert((*(uint32_t *)((intptr_t)stm->instance + SIZE_AUDIOTRACK_INSTANCE -
+                        4)) == 0xbaadbaad);
 
   if (ctx->klass.check(stm->instance)) {
     ALOG("stream not initialized properly.");
@@ -418,25 +449,24 @@ audiotrack_stream_set_volume(cubeb_stream * stream, float volume)
 }
 
 static struct cubeb_ops const audiotrack_ops = {
-  .init = audiotrack_init,
-  .get_backend_id = audiotrack_get_backend_id,
-  .get_max_channel_count = audiotrack_get_max_channel_count,
-  .get_min_latency = audiotrack_get_min_latency,
-  .get_preferred_sample_rate = audiotrack_get_preferred_sample_rate,
-  .enumerate_devices = NULL,
-  .device_collection_destroy = NULL,
-  .destroy = audiotrack_destroy,
-  .stream_init = audiotrack_stream_init,
-  .stream_destroy = audiotrack_stream_destroy,
-  .stream_start = audiotrack_stream_start,
-  .stream_stop = audiotrack_stream_stop,
-  .stream_get_position = audiotrack_stream_get_position,
-  .stream_get_latency = audiotrack_stream_get_latency,
-  .stream_get_input_latency = NULL,
-  .stream_set_volume = audiotrack_stream_set_volume,
-  .stream_set_name = NULL,
-  .stream_get_current_device = NULL,
-  .stream_device_destroy = NULL,
-  .stream_register_device_changed_callback = NULL,
-  .register_device_collection_changed = NULL
-};
+    .init = audiotrack_init,
+    .get_backend_id = audiotrack_get_backend_id,
+    .get_max_channel_count = audiotrack_get_max_channel_count,
+    .get_min_latency = audiotrack_get_min_latency,
+    .get_preferred_sample_rate = audiotrack_get_preferred_sample_rate,
+    .enumerate_devices = NULL,
+    .device_collection_destroy = NULL,
+    .destroy = audiotrack_destroy,
+    .stream_init = audiotrack_stream_init,
+    .stream_destroy = audiotrack_stream_destroy,
+    .stream_start = audiotrack_stream_start,
+    .stream_stop = audiotrack_stream_stop,
+    .stream_get_position = audiotrack_stream_get_position,
+    .stream_get_latency = audiotrack_stream_get_latency,
+    .stream_get_input_latency = NULL,
+    .stream_set_volume = audiotrack_stream_set_volume,
+    .stream_set_name = NULL,
+    .stream_get_current_device = NULL,
+    .stream_device_destroy = NULL,
+    .stream_register_device_changed_callback = NULL,
+    .register_device_collection_changed = NULL};
diff --git a/src/cubeb_audiounit.cpp b/src/cubeb_audiounit.cpp
index 9d800fb..02cd134 100644
--- a/src/cubeb_audiounit.cpp
+++ b/src/cubeb_audiounit.cpp
@@ -6,23 +6,23 @@
  */
 #undef NDEBUG
 
+#include <AudioUnit/AudioUnit.h>
 #include <TargetConditionals.h>
 #include <assert.h>
 #include <mach/mach_time.h>
 #include <pthread.h>
 #include <stdlib.h>
-#include <AudioUnit/AudioUnit.h>
 #if !TARGET_OS_IPHONE
 #include <AvailabilityMacros.h>
 #include <CoreAudio/AudioHardware.h>
 #include <CoreAudio/HostTime.h>
 #include <CoreFoundation/CoreFoundation.h>
 #endif
-#include <CoreAudio/CoreAudioTypes.h>
-#include <AudioToolbox/AudioToolbox.h>
-#include "cubeb/cubeb.h"
 #include "cubeb-internal.h"
+#include "cubeb/cubeb.h"
 #include "cubeb_mixer.h"
+#include <AudioToolbox/AudioToolbox.h>
+#include <CoreAudio/CoreAudioTypes.h>
 #if !TARGET_OS_IPHONE
 #include "cubeb_osx_run_loop.h"
 #endif
@@ -30,10 +30,10 @@
 #include "cubeb_ring_array.h"
 #include <algorithm>
 #include <atomic>
-#include <vector>
 #include <set>
-#include <sys/time.h>
 #include <string>
+#include <sys/time.h>
+#include <vector>
 
 using namespace std;
 
@@ -41,8 +41,8 @@ using namespace std;
 typedef UInt32 AudioFormatFlags;
 #endif
 
-#define AU_OUT_BUS    0
-#define AU_IN_BUS     1
+#define AU_OUT_BUS 0
+#define AU_IN_BUS 1
 
 const char * DISPATCH_QUEUE_LABEL = "org.mozilla.cubeb";
 const char * PRIVATE_AGGREGATE_DEVICE_NAME = "CubebAggregateDevice";
@@ -50,12 +50,20 @@ const char * PRIVATE_AGGREGATE_DEVICE_NAME = "CubebAggregateDevice";
 #ifdef ALOGV
 #undef ALOGV
 #endif
-#define ALOGV(msg, ...) dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{LOGV(msg, ##__VA_ARGS__);})
+#define ALOGV(msg, ...)                                                        \
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0),   \
+                 ^{                                                            \
+                   LOGV(msg, ##__VA_ARGS__);                                   \
+                 })
 
 #ifdef ALOG
 #undef ALOG
 #endif
-#define ALOG(msg, ...) dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{LOG(msg, ##__VA_ARGS__);})
+#define ALOG(msg, ...)                                                         \
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0),   \
+                 ^{                                                            \
+                   LOG(msg, ##__VA_ARGS__);                                    \
+                 })
 
 /* Testing empirically, some headsets report a minimal latency that is very
  * low, but this does not work in practice. Lie and say the minimum is 256
@@ -64,64 +72,63 @@ const uint32_t SAFE_MIN_LATENCY_FRAMES = 128;
 const uint32_t SAFE_MAX_LATENCY_FRAMES = 512;
 
 const AudioObjectPropertyAddress DEFAULT_INPUT_DEVICE_PROPERTY_ADDRESS = {
-  kAudioHardwarePropertyDefaultInputDevice,
-  kAudioObjectPropertyScopeGlobal,
-  kAudioObjectPropertyElementMaster
-};
+    kAudioHardwarePropertyDefaultInputDevice, kAudioObjectPropertyScopeGlobal,
+    kAudioObjectPropertyElementMaster};
 
 const AudioObjectPropertyAddress DEFAULT_OUTPUT_DEVICE_PROPERTY_ADDRESS = {
-  kAudioHardwarePropertyDefaultOutputDevice,
-  kAudioObjectPropertyScopeGlobal,
-  kAudioObjectPropertyElementMaster
-};
+    kAudioHardwarePropertyDefaultOutputDevice, kAudioObjectPropertyScopeGlobal,
+    kAudioObjectPropertyElementMaster};
 
 const AudioObjectPropertyAddress DEVICE_IS_ALIVE_PROPERTY_ADDRESS = {
-  kAudioDevicePropertyDeviceIsAlive,
-  kAudioObjectPropertyScopeGlobal,
-  kAudioObjectPropertyElementMaster
-};
+    kAudioDevicePropertyDeviceIsAlive, kAudioObjectPropertyScopeGlobal,
+    kAudioObjectPropertyElementMaster};
 
 const AudioObjectPropertyAddress DEVICES_PROPERTY_ADDRESS = {
-  kAudioHardwarePropertyDevices,
-  kAudioObjectPropertyScopeGlobal,
-  kAudioObjectPropertyElementMaster
-};
+    kAudioHardwarePropertyDevices, kAudioObjectPropertyScopeGlobal,
+    kAudioObjectPropertyElementMaster};
 
 const AudioObjectPropertyAddress INPUT_DATA_SOURCE_PROPERTY_ADDRESS = {
-  kAudioDevicePropertyDataSource,
-  kAudioDevicePropertyScopeInput,
-  kAudioObjectPropertyElementMaster
-};
+    kAudioDevicePropertyDataSource, kAudioDevicePropertyScopeInput,
+    kAudioObjectPropertyElementMaster};
 
 const AudioObjectPropertyAddress OUTPUT_DATA_SOURCE_PROPERTY_ADDRESS = {
-  kAudioDevicePropertyDataSource,
-  kAudioDevicePropertyScopeOutput,
-  kAudioObjectPropertyElementMaster
-};
+    kAudioDevicePropertyDataSource, kAudioDevicePropertyScopeOutput,
+    kAudioObjectPropertyElementMaster};
 
 typedef uint32_t device_flags_value;
 
 enum device_flags {
-  DEV_UNKNOWN           = 0x00, /* Unknown */
-  DEV_INPUT             = 0x01, /* Record device like mic */
-  DEV_OUTPUT            = 0x02, /* Playback device like speakers */
-  DEV_SYSTEM_DEFAULT    = 0x04, /* System default device */
-  DEV_SELECTED_DEFAULT  = 0x08, /* User selected to use the system default device */
+  DEV_UNKNOWN = 0x00,        /* Unknown */
+  DEV_INPUT = 0x01,          /* Record device like mic */
+  DEV_OUTPUT = 0x02,         /* Playback device like speakers */
+  DEV_SYSTEM_DEFAULT = 0x04, /* System default device */
+  DEV_SELECTED_DEFAULT =
+      0x08, /* User selected to use the system default device */
 };
 
-void audiounit_stream_stop_internal(cubeb_stream * stm);
-static int audiounit_stream_start_internal(cubeb_stream * stm);
-static void audiounit_close_stream(cubeb_stream *stm);
-static int audiounit_setup_stream(cubeb_stream *stm);
+void
+audiounit_stream_stop_internal(cubeb_stream * stm);
+static int
+audiounit_stream_start_internal(cubeb_stream * stm);
+static void
+audiounit_close_stream(cubeb_stream * stm);
+static int
+audiounit_setup_stream(cubeb_stream * stm);
 static vector<AudioObjectID>
 audiounit_get_devices_of_type(cubeb_device_type devtype);
-static UInt32 audiounit_get_device_presentation_latency(AudioObjectID devid, AudioObjectPropertyScope scope);
+static UInt32
+audiounit_get_device_presentation_latency(AudioObjectID devid,
+                                          AudioObjectPropertyScope scope);
 
 #if !TARGET_OS_IPHONE
-static AudioObjectID audiounit_get_default_device_id(cubeb_device_type type);
-static int audiounit_uninstall_device_changed_callback(cubeb_stream * stm);
-static int audiounit_uninstall_system_changed_callback(cubeb_stream * stm);
-static void audiounit_reinit_stream_async(cubeb_stream * stm, device_flags_value flags);
+static AudioObjectID
+audiounit_get_default_device_id(cubeb_device_type type);
+static int
+audiounit_uninstall_device_changed_callback(cubeb_stream * stm);
+static int
+audiounit_uninstall_system_changed_callback(cubeb_stream * stm);
+static void
+audiounit_reinit_stream_async(cubeb_stream * stm, device_flags_value flags);
 #endif
 
 extern cubeb_ops const audiounit_ops;
@@ -131,27 +138,31 @@ struct cubeb {
   owned_critical_section mutex;
   int active_streams = 0;
   uint32_t global_latency_frames = 0;
-  cubeb_device_collection_changed_callback input_collection_changed_callback = nullptr;
+  cubeb_device_collection_changed_callback input_collection_changed_callback =
+      nullptr;
   void * input_collection_changed_user_ptr = nullptr;
-  cubeb_device_collection_changed_callback output_collection_changed_callback = nullptr;
+  cubeb_device_collection_changed_callback output_collection_changed_callback =
+      nullptr;
   void * output_collection_changed_user_ptr = nullptr;
   // Store list of devices to detect changes
   vector<AudioObjectID> input_device_array;
   vector<AudioObjectID> output_device_array;
   // The queue should be released when it’s no longer needed.
-  dispatch_queue_t serial_queue = dispatch_queue_create(DISPATCH_QUEUE_LABEL, DISPATCH_QUEUE_SERIAL);
+  dispatch_queue_t serial_queue =
+      dispatch_queue_create(DISPATCH_QUEUE_LABEL, DISPATCH_QUEUE_SERIAL);
   // Current used channel layout
-  atomic<cubeb_channel_layout> layout{ CUBEB_LAYOUT_UNDEFINED };
+  atomic<cubeb_channel_layout> layout{CUBEB_LAYOUT_UNDEFINED};
   uint32_t channels = 0;
 };
 
 static unique_ptr<AudioChannelLayout, decltype(&free)>
 make_sized_audio_channel_layout(size_t sz)
 {
-    assert(sz >= sizeof(AudioChannelLayout));
-    AudioChannelLayout * acl = reinterpret_cast<AudioChannelLayout *>(calloc(1, sz));
-    assert(acl); // Assert the allocation works.
-    return unique_ptr<AudioChannelLayout, decltype(&free)>(acl, free);
+  assert(sz >= sizeof(AudioChannelLayout));
+  AudioChannelLayout * acl =
+      reinterpret_cast<AudioChannelLayout *>(calloc(1, sz));
+  assert(acl); // Assert the allocation works.
+  return unique_ptr<AudioChannelLayout, decltype(&free)>(acl, free);
 }
 
 enum class io_side {
@@ -183,13 +194,10 @@ struct property_listener {
 
   property_listener(AudioDeviceID id,
                     const AudioObjectPropertyAddress * address,
-                    AudioObjectPropertyListenerProc proc,
-                    cubeb_stream * stm)
-    : device_id(id)
-    , property_address(address)
-    , callback(proc)
-    , stream(stm)
-  {}
+                    AudioObjectPropertyListenerProc proc, cubeb_stream * stm)
+      : device_id(id), property_address(address), callback(proc), stream(stm)
+  {
+  }
 };
 
 struct cubeb_stream {
@@ -205,8 +213,12 @@ struct cubeb_stream {
   cubeb_device_changed_callback device_changed_callback = nullptr;
   owned_critical_section device_changed_callback_lock;
   /* Stream creation parameters */
-  cubeb_stream_params input_stream_params = { CUBEB_SAMPLE_FLOAT32NE, 0, 0, CUBEB_LAYOUT_UNDEFINED, CUBEB_STREAM_PREF_NONE };
-  cubeb_stream_params output_stream_params = { CUBEB_SAMPLE_FLOAT32NE, 0, 0, CUBEB_LAYOUT_UNDEFINED, CUBEB_STREAM_PREF_NONE };
+  cubeb_stream_params input_stream_params = {CUBEB_SAMPLE_FLOAT32NE, 0, 0,
+                                             CUBEB_LAYOUT_UNDEFINED,
+                                             CUBEB_STREAM_PREF_NONE};
+  cubeb_stream_params output_stream_params = {CUBEB_SAMPLE_FLOAT32NE, 0, 0,
+                                              CUBEB_LAYOUT_UNDEFINED,
+                                              CUBEB_STREAM_PREF_NONE};
   device_info input_device;
   device_info output_device;
   /* Format descriptions */
@@ -226,27 +238,29 @@ struct cubeb_stream {
   // Only accessed on input/output callback thread and during initial configure.
   unique_ptr<auto_array_wrapper> input_linear_buffer;
   /* Frame counters */
-  atomic<uint64_t> frames_played{ 0 };
+  atomic<uint64_t> frames_played{0};
   uint64_t frames_queued = 0;
   // How many frames got read from the input since the stream started (includes
   // padded silence)
-  atomic<int64_t> frames_read{ 0 };
+  atomic<int64_t> frames_read{0};
   // How many frames got written to the output device since the stream started
-  atomic<int64_t> frames_written{ 0 };
-  atomic<bool> shutdown{ true };
-  atomic<bool> draining{ false };
-  atomic<bool> reinit_pending { false };
-  atomic<bool> destroy_pending{ false };
+  atomic<int64_t> frames_written{0};
+  atomic<bool> shutdown{true};
+  atomic<bool> draining{false};
+  atomic<bool> reinit_pending{false};
+  atomic<bool> destroy_pending{false};
   /* Latency requested by the user. */
   uint32_t latency_frames = 0;
-  atomic<uint32_t> current_latency_frames{ 0 };
-  atomic<uint32_t> total_output_latency_frames { 0 };
+  atomic<uint32_t> current_latency_frames{0};
+  atomic<uint32_t> total_output_latency_frames{0};
   unique_ptr<cubeb_resampler, decltype(&cubeb_resampler_destroy)> resampler;
   /* This is true if a device change callback is currently running.  */
-  atomic<bool> switching_device{ false };
-  atomic<bool> buffer_size_change_state{ false };
-  AudioDeviceID aggregate_device_id = kAudioObjectUnknown;  // the aggregate device id
-  AudioObjectID plugin_id = kAudioObjectUnknown;            // used to create aggregate device
+  atomic<bool> switching_device{false};
+  atomic<bool> buffer_size_change_state{false};
+  AudioDeviceID aggregate_device_id =
+      kAudioObjectUnknown; // the aggregate device id
+  AudioObjectID plugin_id =
+      kAudioObjectUnknown; // used to create aggregate device
   /* Mixer interface */
   unique_ptr<cubeb_mixer, decltype(&cubeb_mixer_destroy)> mixer;
   /* Buffer where remixing/resampling will occur when upmixing is required */
@@ -261,12 +275,14 @@ struct cubeb_stream {
   unique_ptr<property_listener> output_source_listener;
 };
 
-bool has_input(cubeb_stream * stm)
+bool
+has_input(cubeb_stream * stm)
 {
   return stm->input_stream_params.rate != 0;
 }
 
-bool has_output(cubeb_stream * stm)
+bool
+has_output(cubeb_stream * stm)
 {
   return stm->output_stream_params.rate != 0;
 }
@@ -275,44 +291,44 @@ cubeb_channel
 channel_label_to_cubeb_channel(UInt32 label)
 {
   switch (label) {
-    case kAudioChannelLabel_Left:
-      return CHANNEL_FRONT_LEFT;
-    case kAudioChannelLabel_Right:
-      return CHANNEL_FRONT_RIGHT;
-    case kAudioChannelLabel_Center:
-      return CHANNEL_FRONT_CENTER;
-    case kAudioChannelLabel_LFEScreen:
-      return CHANNEL_LOW_FREQUENCY;
-    case kAudioChannelLabel_LeftSurround:
-      return CHANNEL_BACK_LEFT;
-    case kAudioChannelLabel_RightSurround:
-      return CHANNEL_BACK_RIGHT;
-    case kAudioChannelLabel_LeftCenter:
-      return CHANNEL_FRONT_LEFT_OF_CENTER;
-    case kAudioChannelLabel_RightCenter:
-      return CHANNEL_FRONT_RIGHT_OF_CENTER;
-    case kAudioChannelLabel_CenterSurround:
-      return CHANNEL_BACK_CENTER;
-    case kAudioChannelLabel_LeftSurroundDirect:
-      return CHANNEL_SIDE_LEFT;
-    case kAudioChannelLabel_RightSurroundDirect:
-      return CHANNEL_SIDE_RIGHT;
-    case kAudioChannelLabel_TopCenterSurround:
-      return CHANNEL_TOP_CENTER;
-    case kAudioChannelLabel_VerticalHeightLeft:
-      return CHANNEL_TOP_FRONT_LEFT;
-    case kAudioChannelLabel_VerticalHeightCenter:
-      return CHANNEL_TOP_FRONT_CENTER;
-    case kAudioChannelLabel_VerticalHeightRight:
-      return CHANNEL_TOP_FRONT_RIGHT;
-    case kAudioChannelLabel_TopBackLeft:
-      return CHANNEL_TOP_BACK_LEFT;
-    case kAudioChannelLabel_TopBackCenter:
-      return CHANNEL_TOP_BACK_CENTER;
-    case kAudioChannelLabel_TopBackRight:
-      return CHANNEL_TOP_BACK_RIGHT;
-    default:
-      return CHANNEL_UNKNOWN;
+  case kAudioChannelLabel_Left:
+    return CHANNEL_FRONT_LEFT;
+  case kAudioChannelLabel_Right:
+    return CHANNEL_FRONT_RIGHT;
+  case kAudioChannelLabel_Center:
+    return CHANNEL_FRONT_CENTER;
+  case kAudioChannelLabel_LFEScreen:
+    return CHANNEL_LOW_FREQUENCY;
+  case kAudioChannelLabel_LeftSurround:
+    return CHANNEL_BACK_LEFT;
+  case kAudioChannelLabel_RightSurround:
+    return CHANNEL_BACK_RIGHT;
+  case kAudioChannelLabel_LeftCenter:
+    return CHANNEL_FRONT_LEFT_OF_CENTER;
+  case kAudioChannelLabel_RightCenter:
+    return CHANNEL_FRONT_RIGHT_OF_CENTER;
+  case kAudioChannelLabel_CenterSurround:
+    return CHANNEL_BACK_CENTER;
+  case kAudioChannelLabel_LeftSurroundDirect:
+    return CHANNEL_SIDE_LEFT;
+  case kAudioChannelLabel_RightSurroundDirect:
+    return CHANNEL_SIDE_RIGHT;
+  case kAudioChannelLabel_TopCenterSurround:
+    return CHANNEL_TOP_CENTER;
+  case kAudioChannelLabel_VerticalHeightLeft:
+    return CHANNEL_TOP_FRONT_LEFT;
+  case kAudioChannelLabel_VerticalHeightCenter:
+    return CHANNEL_TOP_FRONT_CENTER;
+  case kAudioChannelLabel_VerticalHeightRight:
+    return CHANNEL_TOP_FRONT_RIGHT;
+  case kAudioChannelLabel_TopBackLeft:
+    return CHANNEL_TOP_BACK_LEFT;
+  case kAudioChannelLabel_TopBackCenter:
+    return CHANNEL_TOP_BACK_CENTER;
+  case kAudioChannelLabel_TopBackRight:
+    return CHANNEL_TOP_BACK_RIGHT;
+  default:
+    return CHANNEL_UNKNOWN;
   }
 }
 
@@ -320,44 +336,44 @@ AudioChannelLabel
 cubeb_channel_to_channel_label(cubeb_channel channel)
 {
   switch (channel) {
-    case CHANNEL_FRONT_LEFT:
-      return kAudioChannelLabel_Left;
-    case CHANNEL_FRONT_RIGHT:
-      return kAudioChannelLabel_Right;
-    case CHANNEL_FRONT_CENTER:
-      return kAudioChannelLabel_Center;
-    case CHANNEL_LOW_FREQUENCY:
-      return kAudioChannelLabel_LFEScreen;
-    case CHANNEL_BACK_LEFT:
-      return kAudioChannelLabel_LeftSurround;
-    case CHANNEL_BACK_RIGHT:
-      return kAudioChannelLabel_RightSurround;
-    case CHANNEL_FRONT_LEFT_OF_CENTER:
-      return kAudioChannelLabel_LeftCenter;
-    case CHANNEL_FRONT_RIGHT_OF_CENTER:
-      return kAudioChannelLabel_RightCenter;
-    case CHANNEL_BACK_CENTER:
-      return kAudioChannelLabel_CenterSurround;
-    case CHANNEL_SIDE_LEFT:
-      return kAudioChannelLabel_LeftSurroundDirect;
-    case CHANNEL_SIDE_RIGHT:
-      return kAudioChannelLabel_RightSurroundDirect;
-    case CHANNEL_TOP_CENTER:
-      return kAudioChannelLabel_TopCenterSurround;
-    case CHANNEL_TOP_FRONT_LEFT:
-      return kAudioChannelLabel_VerticalHeightLeft;
-    case CHANNEL_TOP_FRONT_CENTER:
-      return kAudioChannelLabel_VerticalHeightCenter;
-    case CHANNEL_TOP_FRONT_RIGHT:
-      return kAudioChannelLabel_VerticalHeightRight;
-    case CHANNEL_TOP_BACK_LEFT:
-      return kAudioChannelLabel_TopBackLeft;
-    case CHANNEL_TOP_BACK_CENTER:
-      return kAudioChannelLabel_TopBackCenter;
-    case CHANNEL_TOP_BACK_RIGHT:
-      return kAudioChannelLabel_TopBackRight;
-    default:
-      return kAudioChannelLabel_Unknown;
+  case CHANNEL_FRONT_LEFT:
+    return kAudioChannelLabel_Left;
+  case CHANNEL_FRONT_RIGHT:
+    return kAudioChannelLabel_Right;
+  case CHANNEL_FRONT_CENTER:
+    return kAudioChannelLabel_Center;
+  case CHANNEL_LOW_FREQUENCY:
+    return kAudioChannelLabel_LFEScreen;
+  case CHANNEL_BACK_LEFT:
+    return kAudioChannelLabel_LeftSurround;
+  case CHANNEL_BACK_RIGHT:
+    return kAudioChannelLabel_RightSurround;
+  case CHANNEL_FRONT_LEFT_OF_CENTER:
+    return kAudioChannelLabel_LeftCenter;
+  case CHANNEL_FRONT_RIGHT_OF_CENTER:
+    return kAudioChannelLabel_RightCenter;
+  case CHANNEL_BACK_CENTER:
+    return kAudioChannelLabel_CenterSurround;
+  case CHANNEL_SIDE_LEFT:
+    return kAudioChannelLabel_LeftSurroundDirect;
+  case CHANNEL_SIDE_RIGHT:
+    return kAudioChannelLabel_RightSurroundDirect;
+  case CHANNEL_TOP_CENTER:
+    return kAudioChannelLabel_TopCenterSurround;
+  case CHANNEL_TOP_FRONT_LEFT:
+    return kAudioChannelLabel_VerticalHeightLeft;
+  case CHANNEL_TOP_FRONT_CENTER:
+    return kAudioChannelLabel_VerticalHeightCenter;
+  case CHANNEL_TOP_FRONT_RIGHT:
+    return kAudioChannelLabel_VerticalHeightRight;
+  case CHANNEL_TOP_BACK_LEFT:
+    return kAudioChannelLabel_TopBackLeft;
+  case CHANNEL_TOP_BACK_CENTER:
+    return kAudioChannelLabel_TopBackCenter;
+  case CHANNEL_TOP_BACK_RIGHT:
+    return kAudioChannelLabel_TopBackRight;
+  default:
+    return kAudioChannelLabel_Unknown;
   }
 }
 
@@ -425,10 +441,8 @@ audiounit_make_silent(AudioBuffer * ioData)
 }
 
 static OSStatus
-audiounit_render_input(cubeb_stream * stm,
-                       AudioUnitRenderActionFlags * flags,
-                       AudioTimeStamp const * tstamp,
-                       UInt32 bus,
+audiounit_render_input(cubeb_stream * stm, AudioUnitRenderActionFlags * flags,
+                       AudioTimeStamp const * tstamp, UInt32 bus,
                        UInt32 input_frames)
 {
   /* Create the AudioBufferList to store input. */
@@ -436,16 +450,13 @@ audiounit_render_input(cubeb_stream * stm,
   input_buffer_list.mBuffers[0].mDataByteSize =
       stm->input_desc.mBytesPerFrame * input_frames;
   input_buffer_list.mBuffers[0].mData = nullptr;
-  input_buffer_list.mBuffers[0].mNumberChannels = stm->input_desc.mChannelsPerFrame;
+  input_buffer_list.mBuffers[0].mNumberChannels =
+      stm->input_desc.mChannelsPerFrame;
   input_buffer_list.mNumberBuffers = 1;
 
   /* Render input samples */
-  OSStatus r = AudioUnitRender(stm->input_unit,
-                               flags,
-                               tstamp,
-                               bus,
-                               input_frames,
-                               &input_buffer_list);
+  OSStatus r = AudioUnitRender(stm->input_unit, flags, tstamp, bus,
+                               input_frames, &input_buffer_list);
 
   if (r != noErr) {
     LOG("AudioUnitRender rv=%d", r);
@@ -461,35 +472,34 @@ audiounit_render_input(cubeb_stream * stm,
     // For now state that no error occurred and feed silence, stream will be
     // resumed once reinit has completed.
     ALOGV("(%p) input: reinit pending feeding silence instead", stm);
-    stm->input_linear_buffer->push_silence(input_frames * stm->input_desc.mChannelsPerFrame);
+    stm->input_linear_buffer->push_silence(input_frames *
+                                           stm->input_desc.mChannelsPerFrame);
   } else {
     /* Copy input data in linear buffer. */
     stm->input_linear_buffer->push(input_buffer_list.mBuffers[0].mData,
-                                   input_frames * stm->input_desc.mChannelsPerFrame);
+                                   input_frames *
+                                       stm->input_desc.mChannelsPerFrame);
   }
 
   /* Advance input frame counter. */
   assert(input_frames > 0);
   stm->frames_read += input_frames;
 
-  ALOGV("(%p) input: buffers %u, size %u, channels %u, rendered frames %d, total frames %lu.",
-        stm,
-        (unsigned int) input_buffer_list.mNumberBuffers,
-        (unsigned int) input_buffer_list.mBuffers[0].mDataByteSize,
-        (unsigned int) input_buffer_list.mBuffers[0].mNumberChannels,
-        (unsigned int) input_frames,
+  ALOGV("(%p) input: buffers %u, size %u, channels %u, rendered frames %d, "
+        "total frames %lu.",
+        stm, (unsigned int)input_buffer_list.mNumberBuffers,
+        (unsigned int)input_buffer_list.mBuffers[0].mDataByteSize,
+        (unsigned int)input_buffer_list.mBuffers[0].mNumberChannels,
+        (unsigned int)input_frames,
         stm->input_linear_buffer->length() / stm->input_desc.mChannelsPerFrame);
 
   return noErr;
 }
 
 static OSStatus
-audiounit_input_callback(void * user_ptr,
-                         AudioUnitRenderActionFlags * flags,
-                         AudioTimeStamp const * tstamp,
-                         UInt32 bus,
-                         UInt32 input_frames,
-                         AudioBufferList * /* bufs */)
+audiounit_input_callback(void * user_ptr, AudioUnitRenderActionFlags * flags,
+                         AudioTimeStamp const * tstamp, UInt32 bus,
+                         UInt32 input_frames, AudioBufferList * /* bufs */)
 {
   cubeb_stream * stm = static_cast<cubeb_stream *>(user_ptr);
 
@@ -524,13 +534,13 @@ audiounit_input_callback(void * user_ptr,
 
   /* Input only. Call the user callback through resampler.
      Resampler will deliver input buffer in the correct rate. */
-  assert(input_frames <= stm->input_linear_buffer->length() / stm->input_desc.mChannelsPerFrame);
-  long total_input_frames = stm->input_linear_buffer->length() / stm->input_desc.mChannelsPerFrame;
+  assert(input_frames <= stm->input_linear_buffer->length() /
+                             stm->input_desc.mChannelsPerFrame);
+  long total_input_frames =
+      stm->input_linear_buffer->length() / stm->input_desc.mChannelsPerFrame;
   long outframes = cubeb_resampler_fill(stm->resampler.get(),
                                         stm->input_linear_buffer->data(),
-                                        &total_input_frames,
-                                        NULL,
-                                        0);
+                                        &total_input_frames, NULL, 0);
   stm->draining = outframes < total_input_frames;
 
   // Reset input buffer
@@ -540,24 +550,17 @@ audiounit_input_callback(void * user_ptr,
 }
 
 static void
-audiounit_mix_output_buffer(cubeb_stream * stm,
-                            size_t output_frames,
-                            void * input_buffer,
-                            size_t input_buffer_size,
-                            void * output_buffer,
-                            size_t output_buffer_size)
+audiounit_mix_output_buffer(cubeb_stream * stm, size_t output_frames,
+                            void * input_buffer, size_t input_buffer_size,
+                            void * output_buffer, size_t output_buffer_size)
 {
   assert(input_buffer_size >=
          cubeb_sample_size(stm->output_stream_params.format) *
-           stm->output_stream_params.channels * output_frames);
+             stm->output_stream_params.channels * output_frames);
   assert(output_buffer_size >= stm->output_desc.mBytesPerFrame * output_frames);
 
-  int r = cubeb_mixer_mix(stm->mixer.get(),
-                          output_frames,
-                          input_buffer,
-                          input_buffer_size,
-                          output_buffer,
-                          output_buffer_size);
+  int r = cubeb_mixer_mix(stm->mixer.get(), output_frames, input_buffer,
+                          input_buffer_size, output_buffer, output_buffer_size);
   if (r != 0) {
     LOG("Remix error = %d", r);
   }
@@ -579,10 +582,8 @@ minimum_resampling_input_frames(cubeb_stream * stm, uint32_t output_frames)
 static OSStatus
 audiounit_output_callback(void * user_ptr,
                           AudioUnitRenderActionFlags * /* flags */,
-                          AudioTimeStamp const * tstamp,
-                          UInt32 bus,
-                          UInt32 output_frames,
-                          AudioBufferList * outBufferList)
+                          AudioTimeStamp const * tstamp, UInt32 bus,
+                          UInt32 output_frames, AudioBufferList * outBufferList)
 {
   assert(AU_OUT_BUS == bus);
   assert(outBufferList->mNumberBuffers == 1);
@@ -596,18 +597,22 @@ audiounit_output_callback(void * user_ptr,
   const int ns2s = 1e9;
   // The total output latency is the timestamp difference + the stream latency +
   // the hardware latency.
-  stm->total_output_latency_frames = output_latency_ns * stm->output_hw_rate / ns2s + stm->current_latency_frames;
-
-  ALOGV("(%p) output: buffers %u, size %u, channels %u, frames %u, total input frames %lu.",
-        stm,
-        (unsigned int) outBufferList->mNumberBuffers,
-        (unsigned int) outBufferList->mBuffers[0].mDataByteSize,
-        (unsigned int) outBufferList->mBuffers[0].mNumberChannels,
-        (unsigned int) output_frames,
-        has_input(stm) ? stm->input_linear_buffer->length() / stm->input_desc.mChannelsPerFrame : 0);
+  stm->total_output_latency_frames =
+      output_latency_ns * stm->output_hw_rate / ns2s +
+      stm->current_latency_frames;
+
+  ALOGV("(%p) output: buffers %u, size %u, channels %u, frames %u, total input "
+        "frames %lu.",
+        stm, (unsigned int)outBufferList->mNumberBuffers,
+        (unsigned int)outBufferList->mBuffers[0].mDataByteSize,
+        (unsigned int)outBufferList->mBuffers[0].mNumberChannels,
+        (unsigned int)output_frames,
+        has_input(stm) ? stm->input_linear_buffer->length() /
+                             stm->input_desc.mChannelsPerFrame
+                       : 0);
 
   long input_frames = 0;
-  void * output_buffer = NULL, * input_buffer = NULL;
+  void *output_buffer = NULL, *input_buffer = NULL;
 
   if (stm->shutdown) {
     ALOG("(%p) output shutdown.", stm);
@@ -648,31 +653,35 @@ audiounit_output_callback(void * user_ptr,
      * currently switching, we add some silence as well to compensate for the
      * fact that we're lacking some input data. */
     uint32_t input_frames_needed =
-      minimum_resampling_input_frames(stm, stm->frames_written);
+        minimum_resampling_input_frames(stm, stm->frames_written);
     long missing_frames = input_frames_needed - stm->frames_read;
     if (missing_frames > 0) {
-      stm->input_linear_buffer->push_silence(missing_frames * stm->input_desc.mChannelsPerFrame);
+      stm->input_linear_buffer->push_silence(missing_frames *
+                                             stm->input_desc.mChannelsPerFrame);
       stm->frames_read = input_frames_needed;
 
-      ALOG("(%p) %s pushed %ld frames of input silence.", stm, stm->frames_read == 0 ? "Input hasn't started," :
-           stm->switching_device ? "Device switching," : "Drop out,", missing_frames);
+      ALOG("(%p) %s pushed %ld frames of input silence.", stm,
+           stm->frames_read == 0   ? "Input hasn't started,"
+           : stm->switching_device ? "Device switching,"
+                                   : "Drop out,",
+           missing_frames);
     }
     input_buffer = stm->input_linear_buffer->data();
-    // Number of input frames in the buffer. It will change to actually used frames
-    // inside fill
-    input_frames = stm->input_linear_buffer->length() / stm->input_desc.mChannelsPerFrame;
+    // Number of input frames in the buffer. It will change to actually used
+    // frames inside fill
+    input_frames =
+        stm->input_linear_buffer->length() / stm->input_desc.mChannelsPerFrame;
   }
 
   /* Call user callback through resampler. */
-  long outframes = cubeb_resampler_fill(stm->resampler.get(),
-                                        input_buffer,
+  long outframes = cubeb_resampler_fill(stm->resampler.get(), input_buffer,
                                         input_buffer ? &input_frames : NULL,
-                                        output_buffer,
-                                        output_frames);
+                                        output_buffer, output_frames);
 
   if (input_buffer) {
     // Pop from the buffer the frames used by the the resampler.
-    stm->input_linear_buffer->pop(input_frames * stm->input_desc.mChannelsPerFrame);
+    stm->input_linear_buffer->pop(input_frames *
+                                  stm->input_desc.mChannelsPerFrame);
   }
 
   if (outframes < 0 || outframes > output_frames) {
@@ -688,7 +697,7 @@ audiounit_output_callback(void * user_ptr,
     return noErr;
   }
 
-  stm->draining = (UInt32) outframes < output_frames;
+  stm->draining = (UInt32)outframes < output_frames;
   stm->frames_played = stm->frames_queued;
   stm->frames_queued += outframes;
 
@@ -698,17 +707,16 @@ audiounit_output_callback(void * user_ptr,
     size_t channels = stm->output_stream_params.channels;
     size_t missing_samples = (output_frames - outframes) * channels;
     size_t size_sample = cubeb_sample_size(stm->output_stream_params.format);
-    /* number of bytes that have been filled with valid audio by the callback. */
+    /* number of bytes that have been filled with valid audio by the callback.
+     */
     size_t audio_byte_count = outframes * channels * size_sample;
-    PodZero((uint8_t*)output_buffer + audio_byte_count,
+    PodZero((uint8_t *)output_buffer + audio_byte_count,
             missing_samples * size_sample);
   }
 
   /* Mixing */
   if (stm->mixer) {
-    audiounit_mix_output_buffer(stm,
-                                output_frames,
-                                output_buffer,
+    audiounit_mix_output_buffer(stm, output_frames, output_buffer,
                                 stm->temp_buffer_size,
                                 outBufferList->mBuffers[0].mData,
                                 outBufferList->mBuffers[0].mDataByteSize);
@@ -739,8 +747,10 @@ audiounit_get_backend_id(cubeb * /* ctx */)
 
 #if !TARGET_OS_IPHONE
 
-static int audiounit_stream_get_volume(cubeb_stream * stm, float * volume);
-static int audiounit_stream_set_volume(cubeb_stream * stm, float volume);
+static int
+audiounit_stream_get_volume(cubeb_stream * stm, float * volume);
+static int
+audiounit_stream_set_volume(cubeb_stream * stm, float volume);
 
 static int
 audiounit_set_device_info(cubeb_stream * stm, AudioDeviceID id, io_side side)
@@ -781,12 +791,11 @@ audiounit_set_device_info(cubeb_stream * stm, AudioDeviceID id, io_side side)
 
   assert(info->id);
   assert(info->flags & DEV_INPUT && !(info->flags & DEV_OUTPUT) ||
-           !(info->flags & DEV_INPUT) && info->flags & DEV_OUTPUT);
+         !(info->flags & DEV_INPUT) && info->flags & DEV_OUTPUT);
 
   return CUBEB_OK;
 }
 
-
 static int
 audiounit_reinit_stream(cubeb_stream * stm, device_flags_value flags)
 {
@@ -818,11 +827,14 @@ audiounit_reinit_stream(cubeb_stream * stm, device_flags_value flags)
      * - The bluetooth device changed from A2DP to/from HFP/HSP profile
      * We first attempt to re-use the same device id, should that fail we will
      * default to the (potentially new) default device. */
-    AudioDeviceID input_device = flags & DEV_INPUT ? stm->input_device.id : kAudioObjectUnknown;
+    AudioDeviceID input_device =
+        flags & DEV_INPUT ? stm->input_device.id : kAudioObjectUnknown;
     if (flags & DEV_INPUT) {
       r = audiounit_set_device_info(stm, input_device, io_side::INPUT);
       if (r != CUBEB_OK) {
-        LOG("(%p) Set input device info failed. This can happen when last media device is unplugged", stm);
+        LOG("(%p) Set input device info failed. This can happen when last "
+            "media device is unplugged",
+            stm);
         return CUBEB_ERROR;
       }
     }
@@ -832,7 +844,9 @@ audiounit_reinit_stream(cubeb_stream * stm, device_flags_value flags)
      * failures. It will change soon when reinit mechanism will be updated. */
     r = audiounit_set_device_info(stm, kAudioObjectUnknown, io_side::OUTPUT);
     if (r != CUBEB_OK) {
-      LOG("(%p) Set output device info failed. This can happen when last media device is unplugged", stm);
+      LOG("(%p) Set output device info failed. This can happen when last media "
+          "device is unplugged",
+          stm);
       return CUBEB_ERROR;
     }
 
@@ -842,7 +856,8 @@ audiounit_reinit_stream(cubeb_stream * stm, device_flags_value flags)
         // Attempt to re-use the same device-id failed, so attempt again with
         // default input device.
         audiounit_close_stream(stm);
-        if (audiounit_set_device_info(stm, kAudioObjectUnknown, io_side::INPUT) != CUBEB_OK ||
+        if (audiounit_set_device_info(stm, kAudioObjectUnknown,
+                                      io_side::INPUT) != CUBEB_OK ||
             audiounit_setup_stream(stm) != CUBEB_OK) {
           LOG("(%p) Second stream reinit failed.", stm);
           return CUBEB_ERROR;
@@ -897,62 +912,68 @@ audiounit_reinit_stream_async(cubeb_stream * stm, device_flags_value flags)
 static char const *
 event_addr_to_string(AudioObjectPropertySelector selector)
 {
-  switch(selector) {
-    case kAudioHardwarePropertyDefaultOutputDevice:
-      return "kAudioHardwarePropertyDefaultOutputDevice";
-    case kAudioHardwarePropertyDefaultInputDevice:
-      return "kAudioHardwarePropertyDefaultInputDevice";
-    case kAudioDevicePropertyDeviceIsAlive:
-      return "kAudioDevicePropertyDeviceIsAlive";
-    case kAudioDevicePropertyDataSource:
-      return "kAudioDevicePropertyDataSource";
-    default:
-      return "Unknown";
+  switch (selector) {
+  case kAudioHardwarePropertyDefaultOutputDevice:
+    return "kAudioHardwarePropertyDefaultOutputDevice";
+  case kAudioHardwarePropertyDefaultInputDevice:
+    return "kAudioHardwarePropertyDefaultInputDevice";
+  case kAudioDevicePropertyDeviceIsAlive:
+    return "kAudioDevicePropertyDeviceIsAlive";
+  case kAudioDevicePropertyDataSource:
+    return "kAudioDevicePropertyDataSource";
+  default:
+    return "Unknown";
   }
 }
 
 static OSStatus
-audiounit_property_listener_callback(AudioObjectID id, UInt32 address_count,
-                                     const AudioObjectPropertyAddress * addresses,
-                                     void * user)
+audiounit_property_listener_callback(
+    AudioObjectID id, UInt32 address_count,
+    const AudioObjectPropertyAddress * addresses, void * user)
 {
-  cubeb_stream * stm = (cubeb_stream*) user;
+  cubeb_stream * stm = (cubeb_stream *)user;
   if (stm->switching_device) {
-    LOG("Switching is already taking place. Skip Event %s for id=%d", event_addr_to_string(addresses[0].mSelector), id);
+    LOG("Switching is already taking place. Skip Event %s for id=%d",
+        event_addr_to_string(addresses[0].mSelector), id);
     return noErr;
   }
   stm->switching_device = true;
 
-  LOG("(%p) Audio device changed, %u events.", stm, (unsigned int) address_count);
+  LOG("(%p) Audio device changed, %u events.", stm,
+      (unsigned int)address_count);
   for (UInt32 i = 0; i < address_count; i++) {
-    switch(addresses[i].mSelector) {
-      case kAudioHardwarePropertyDefaultOutputDevice: {
-          LOG("Event[%u] - mSelector == kAudioHardwarePropertyDefaultOutputDevice for id=%d", (unsigned int) i, id);
-        }
-        break;
-      case kAudioHardwarePropertyDefaultInputDevice: {
-          LOG("Event[%u] - mSelector == kAudioHardwarePropertyDefaultInputDevice for id=%d", (unsigned int) i, id);
-        }
-      break;
-      case kAudioDevicePropertyDeviceIsAlive: {
-          LOG("Event[%u] - mSelector == kAudioDevicePropertyDeviceIsAlive for id=%d", (unsigned int) i, id);
-          // If this is the default input device ignore the event,
-          // kAudioHardwarePropertyDefaultInputDevice will take care of the switch
-          if (stm->input_device.flags & DEV_SYSTEM_DEFAULT) {
-            LOG("It's the default input device, ignore the event");
-            stm->switching_device = false;
-            return noErr;
-          }
-        }
-        break;
-      case kAudioDevicePropertyDataSource: {
-          LOG("Event[%u] - mSelector == kAudioDevicePropertyDataSource for id=%d", (unsigned int) i, id);
-        }
-        break;
-      default:
-        LOG("Event[%u] - mSelector == Unexpected Event id %d, return", (unsigned int) i, addresses[i].mSelector);
+    switch (addresses[i].mSelector) {
+    case kAudioHardwarePropertyDefaultOutputDevice: {
+      LOG("Event[%u] - mSelector == kAudioHardwarePropertyDefaultOutputDevice "
+          "for id=%d",
+          (unsigned int)i, id);
+    } break;
+    case kAudioHardwarePropertyDefaultInputDevice: {
+      LOG("Event[%u] - mSelector == kAudioHardwarePropertyDefaultInputDevice "
+          "for id=%d",
+          (unsigned int)i, id);
+    } break;
+    case kAudioDevicePropertyDeviceIsAlive: {
+      LOG("Event[%u] - mSelector == kAudioDevicePropertyDeviceIsAlive for "
+          "id=%d",
+          (unsigned int)i, id);
+      // If this is the default input device ignore the event,
+      // kAudioHardwarePropertyDefaultInputDevice will take care of the switch
+      if (stm->input_device.flags & DEV_SYSTEM_DEFAULT) {
+        LOG("It's the default input device, ignore the event");
         stm->switching_device = false;
         return noErr;
+      }
+    } break;
+    case kAudioDevicePropertyDataSource: {
+      LOG("Event[%u] - mSelector == kAudioDevicePropertyDataSource for id=%d",
+          (unsigned int)i, id);
+    } break;
+    default:
+      LOG("Event[%u] - mSelector == Unexpected Event id %d, return",
+          (unsigned int)i, addresses[i].mSelector);
+      stm->switching_device = false;
+      return noErr;
     }
   }
 
@@ -966,18 +987,18 @@ audiounit_property_listener_callback(AudioObjectID id, UInt32 address_count,
   }
 
   for (UInt32 i = 0; i < address_count; i++) {
-    switch(addresses[i].mSelector) {
+    switch (addresses[i].mSelector) {
     case kAudioHardwarePropertyDefaultOutputDevice:
     case kAudioHardwarePropertyDefaultInputDevice:
     case kAudioDevicePropertyDeviceIsAlive:
       /* fall through */
     case kAudioDevicePropertyDataSource: {
-        auto_lock dev_cb_lock(stm->device_changed_callback_lock);
-        if (stm->device_changed_callback) {
-          stm->device_changed_callback(stm->user_ptr);
-        }
-        break;
+      auto_lock dev_cb_lock(stm->device_changed_callback_lock);
+      if (stm->device_changed_callback) {
+        stm->device_changed_callback(stm->user_ptr);
       }
+      break;
+    }
     }
   }
 
@@ -992,18 +1013,16 @@ audiounit_add_listener(const property_listener * listener)
   assert(listener);
   return AudioObjectAddPropertyListener(listener->device_id,
                                         listener->property_address,
-                                        listener->callback,
-                                        listener->stream);
+                                        listener->callback, listener->stream);
 }
 
 OSStatus
 audiounit_remove_listener(const property_listener * listener)
 {
   assert(listener);
-  return AudioObjectRemovePropertyListener(listener->device_id,
-                                           listener->property_address,
-                                           listener->callback,
-                                           listener->stream);
+  return AudioObjectRemovePropertyListener(
+      listener->device_id, listener->property_address, listener->callback,
+      listener->stream);
 }
 
 static int
@@ -1013,40 +1032,47 @@ audiounit_install_device_changed_callback(cubeb_stream * stm)
   int r = CUBEB_OK;
 
   if (stm->output_unit) {
-    /* This event will notify us when the data source on the same device changes,
-     * for example when the user plugs in a normal (non-usb) headset in the
-     * headphone jack. */
+    /* This event will notify us when the data source on the same device
+     * changes, for example when the user plugs in a normal (non-usb) headset in
+     * the headphone jack. */
     stm->output_source_listener.reset(new property_listener(
-      stm->output_device.id, &OUTPUT_DATA_SOURCE_PROPERTY_ADDRESS,
-      &audiounit_property_listener_callback, stm));
+        stm->output_device.id, &OUTPUT_DATA_SOURCE_PROPERTY_ADDRESS,
+        &audiounit_property_listener_callback, stm));
     rv = audiounit_add_listener(stm->output_source_listener.get());
     if (rv != noErr) {
       stm->output_source_listener.reset();
-      LOG("AudioObjectAddPropertyListener/output/kAudioDevicePropertyDataSource rv=%d, device id=%d", rv, stm->output_device.id);
+      LOG("AudioObjectAddPropertyListener/output/"
+          "kAudioDevicePropertyDataSource rv=%d, device id=%d",
+          rv, stm->output_device.id);
       r = CUBEB_ERROR;
     }
   }
 
   if (stm->input_unit) {
-    /* This event will notify us when the data source on the input device changes. */
+    /* This event will notify us when the data source on the input device
+     * changes. */
     stm->input_source_listener.reset(new property_listener(
-      stm->input_device.id, &INPUT_DATA_SOURCE_PROPERTY_ADDRESS,
-      &audiounit_property_listener_callback, stm));
+        stm->input_device.id, &INPUT_DATA_SOURCE_PROPERTY_ADDRESS,
+        &audiounit_property_listener_callback, stm));
     rv = audiounit_add_listener(stm->input_source_listener.get());
     if (rv != noErr) {
       stm->input_source_listener.reset();
-      LOG("AudioObjectAddPropertyListener/input/kAudioDevicePropertyDataSource rv=%d, device id=%d", rv, stm->input_device.id);
+      LOG("AudioObjectAddPropertyListener/input/kAudioDevicePropertyDataSource "
+          "rv=%d, device id=%d",
+          rv, stm->input_device.id);
       r = CUBEB_ERROR;
     }
 
     /* Event to notify when the input is going away. */
     stm->input_alive_listener.reset(new property_listener(
-      stm->input_device.id, &DEVICE_IS_ALIVE_PROPERTY_ADDRESS,
-      &audiounit_property_listener_callback, stm));
+        stm->input_device.id, &DEVICE_IS_ALIVE_PROPERTY_ADDRESS,
+        &audiounit_property_listener_callback, stm));
     rv = audiounit_add_listener(stm->input_alive_listener.get());
     if (rv != noErr) {
       stm->input_alive_listener.reset();
-      LOG("AudioObjectAddPropertyListener/input/kAudioDevicePropertyDeviceIsAlive rv=%d, device id =%d", rv, stm->input_device.id);
+      LOG("AudioObjectAddPropertyListener/input/"
+          "kAudioDevicePropertyDeviceIsAlive rv=%d, device id =%d",
+          rv, stm->input_device.id);
       r = CUBEB_ERROR;
     }
   }
@@ -1061,16 +1087,18 @@ audiounit_install_system_changed_callback(cubeb_stream * stm)
 
   if (stm->output_unit) {
     /* This event will notify us when the default audio device changes,
-     * for example when the user plugs in a USB headset and the system chooses it
-     * automatically as the default, or when another device is chosen in the
+     * for example when the user plugs in a USB headset and the system chooses
+     * it automatically as the default, or when another device is chosen in the
      * dropdown list. */
     stm->default_output_listener.reset(new property_listener(
-      kAudioObjectSystemObject, &DEFAULT_OUTPUT_DEVICE_PROPERTY_ADDRESS,
-      &audiounit_property_listener_callback, stm));
+        kAudioObjectSystemObject, &DEFAULT_OUTPUT_DEVICE_PROPERTY_ADDRESS,
+        &audiounit_property_listener_callback, stm));
     r = audiounit_add_listener(stm->default_output_listener.get());
     if (r != noErr) {
       stm->default_output_listener.reset();
-      LOG("AudioObjectAddPropertyListener/output/kAudioHardwarePropertyDefaultOutputDevice rv=%d", r);
+      LOG("AudioObjectAddPropertyListener/output/"
+          "kAudioHardwarePropertyDefaultOutputDevice rv=%d",
+          r);
       return CUBEB_ERROR;
     }
   }
@@ -1078,12 +1106,14 @@ audiounit_install_system_changed_callback(cubeb_stream * stm)
   if (stm->input_unit) {
     /* This event will notify us when the default input device changes. */
     stm->default_input_listener.reset(new property_listener(
-      kAudioObjectSystemObject, &DEFAULT_INPUT_DEVICE_PROPERTY_ADDRESS,
-      &audiounit_property_listener_callback, stm));
+        kAudioObjectSystemObject, &DEFAULT_INPUT_DEVICE_PROPERTY_ADDRESS,
+        &audiounit_property_listener_callback, stm));
     r = audiounit_add_listener(stm->default_input_listener.get());
     if (r != noErr) {
       stm->default_input_listener.reset();
-      LOG("AudioObjectAddPropertyListener/input/kAudioHardwarePropertyDefaultInputDevice rv=%d", r);
+      LOG("AudioObjectAddPropertyListener/input/"
+          "kAudioHardwarePropertyDefaultInputDevice rv=%d",
+          r);
       return CUBEB_ERROR;
     }
   }
@@ -1101,7 +1131,9 @@ audiounit_uninstall_device_changed_callback(cubeb_stream * stm)
   if (stm->output_source_listener) {
     rv = audiounit_remove_listener(stm->output_source_listener.get());
     if (rv != noErr) {
-      LOG("AudioObjectRemovePropertyListener/output/kAudioDevicePropertyDataSource rv=%d, device id=%d", rv, stm->output_device.id);
+      LOG("AudioObjectRemovePropertyListener/output/"
+          "kAudioDevicePropertyDataSource rv=%d, device id=%d",
+          rv, stm->output_device.id);
       r = CUBEB_ERROR;
     }
     stm->output_source_listener.reset();
@@ -1110,7 +1142,9 @@ audiounit_uninstall_device_changed_callback(cubeb_stream * stm)
   if (stm->input_source_listener) {
     rv = audiounit_remove_listener(stm->input_source_listener.get());
     if (rv != noErr) {
-      LOG("AudioObjectRemovePropertyListener/input/kAudioDevicePropertyDataSource rv=%d, device id=%d", rv, stm->input_device.id);
+      LOG("AudioObjectRemovePropertyListener/input/"
+          "kAudioDevicePropertyDataSource rv=%d, device id=%d",
+          rv, stm->input_device.id);
       r = CUBEB_ERROR;
     }
     stm->input_source_listener.reset();
@@ -1119,7 +1153,9 @@ audiounit_uninstall_device_changed_callback(cubeb_stream * stm)
   if (stm->input_alive_listener) {
     rv = audiounit_remove_listener(stm->input_alive_listener.get());
     if (rv != noErr) {
-      LOG("AudioObjectRemovePropertyListener/input/kAudioDevicePropertyDeviceIsAlive rv=%d, device id=%d", rv, stm->input_device.id);
+      LOG("AudioObjectRemovePropertyListener/input/"
+          "kAudioDevicePropertyDeviceIsAlive rv=%d, device id=%d",
+          rv, stm->input_device.id);
       r = CUBEB_ERROR;
     }
     stm->input_alive_listener.reset();
@@ -1159,10 +1195,8 @@ audiounit_get_acceptable_latency_range(AudioValueRange * latency_range)
   OSStatus r;
   AudioDeviceID output_device_id;
   AudioObjectPropertyAddress output_device_buffer_size_range = {
-    kAudioDevicePropertyBufferFrameSizeRange,
-    kAudioDevicePropertyScopeOutput,
-    kAudioObjectPropertyElementMaster
-  };
+      kAudioDevicePropertyBufferFrameSizeRange, kAudioDevicePropertyScopeOutput,
+      kAudioObjectPropertyElementMaster};
 
   output_device_id = audiounit_get_default_device_id(CUBEB_DEVICE_TYPE_OUTPUT);
   if (output_device_id == kAudioObjectUnknown) {
@@ -1174,11 +1208,8 @@ audiounit_get_acceptable_latency_range(AudioValueRange * latency_range)
   size = sizeof(*latency_range);
 
   r = AudioObjectGetPropertyData(output_device_id,
-                                 &output_device_buffer_size_range,
-                                 0,
-                                 NULL,
-                                 &size,
-                                 latency_range);
+                                 &output_device_buffer_size_range, 0, NULL,
+                                 &size, latency_range);
   if (r != noErr) {
     LOG("AudioObjectGetPropertyData/buffer size range rv=%d", r);
     return CUBEB_ERROR;
@@ -1202,8 +1233,8 @@ audiounit_get_default_device_id(cubeb_device_type type)
 
   AudioDeviceID devid;
   UInt32 size = sizeof(AudioDeviceID);
-  if (AudioObjectGetPropertyData(kAudioObjectSystemObject,
-                                 adr, 0, NULL, &size, &devid) != noErr) {
+  if (AudioObjectGetPropertyData(kAudioObjectSystemObject, adr, 0, NULL, &size,
+                                 &devid) != noErr) {
     return kAudioObjectUnknown;
   }
 
@@ -1214,7 +1245,7 @@ int
 audiounit_get_max_channel_count(cubeb * ctx, uint32_t * max_channels)
 {
 #if TARGET_OS_IPHONE
-  //TODO: [[AVAudioSession sharedInstance] maximumOutputNumberOfChannels]
+  // TODO: [[AVAudioSession sharedInstance] maximumOutputNumberOfChannels]
   *max_channels = 2;
 #else
   UInt32 size;
@@ -1222,10 +1253,8 @@ audiounit_get_max_channel_count(cubeb * ctx, uint32_t * max_channels)
   AudioDeviceID output_device_id;
   AudioStreamBasicDescription stream_format;
   AudioObjectPropertyAddress stream_format_address = {
-    kAudioDevicePropertyStreamFormat,
-    kAudioDevicePropertyScopeOutput,
-    kAudioObjectPropertyElementMaster
-  };
+      kAudioDevicePropertyStreamFormat, kAudioDevicePropertyScopeOutput,
+      kAudioObjectPropertyElementMaster};
 
   assert(ctx && max_channels);
 
@@ -1236,12 +1265,8 @@ audiounit_get_max_channel_count(cubeb * ctx, uint32_t * max_channels)
 
   size = sizeof(stream_format);
 
-  r = AudioObjectGetPropertyData(output_device_id,
-                                 &stream_format_address,
-                                 0,
-                                 NULL,
-                                 &size,
-                                 &stream_format);
+  r = AudioObjectGetPropertyData(output_device_id, &stream_format_address, 0,
+                                 NULL, &size, &stream_format);
   if (r != noErr) {
     LOG("AudioObjectPropertyAddress/StreamFormat rv=%d", r);
     return CUBEB_ERROR;
@@ -1253,12 +1278,11 @@ audiounit_get_max_channel_count(cubeb * ctx, uint32_t * max_channels)
 }
 
 static int
-audiounit_get_min_latency(cubeb * /* ctx */,
-                          cubeb_stream_params /* params */,
+audiounit_get_min_latency(cubeb * /* ctx */, cubeb_stream_params /* params */,
                           uint32_t * latency_frames)
 {
 #if TARGET_OS_IPHONE
-  //TODO: [[AVAudioSession sharedInstance] inputLatency]
+  // TODO: [[AVAudioSession sharedInstance] inputLatency]
   return CUBEB_ERROR_NOT_SUPPORTED;
 #else
   AudioValueRange latency_range;
@@ -1267,8 +1291,8 @@ audiounit_get_min_latency(cubeb * /* ctx */,
     return CUBEB_ERROR;
   }
 
-  *latency_frames = max<uint32_t>(latency_range.mMinimum,
-                                       SAFE_MIN_LATENCY_FRAMES);
+  *latency_frames =
+      max<uint32_t>(latency_range.mMinimum, SAFE_MIN_LATENCY_FRAMES);
 #endif
 
   return CUBEB_OK;
@@ -1278,7 +1302,7 @@ static int
 audiounit_get_preferred_sample_rate(cubeb * /* ctx */, uint32_t * rate)
 {
 #if TARGET_OS_IPHONE
-  //TODO
+  // TODO
   return CUBEB_ERROR_NOT_SUPPORTED;
 #else
   UInt32 size;
@@ -1286,10 +1310,8 @@ audiounit_get_preferred_sample_rate(cubeb * /* ctx */, uint32_t * rate)
   Float64 fsamplerate;
   AudioDeviceID output_device_id;
   AudioObjectPropertyAddress samplerate_address = {
-    kAudioDevicePropertyNominalSampleRate,
-    kAudioObjectPropertyScopeGlobal,
-    kAudioObjectPropertyElementMaster
-  };
+      kAudioDevicePropertyNominalSampleRate, kAudioObjectPropertyScopeGlobal,
+      kAudioObjectPropertyElementMaster};
 
   output_device_id = audiounit_get_default_device_id(CUBEB_DEVICE_TYPE_OUTPUT);
   if (output_device_id == kAudioObjectUnknown) {
@@ -1297,12 +1319,8 @@ audiounit_get_preferred_sample_rate(cubeb * /* ctx */, uint32_t * rate)
   }
 
   size = sizeof(fsamplerate);
-  r = AudioObjectGetPropertyData(output_device_id,
-                                 &samplerate_address,
-                                 0,
-                                 NULL,
-                                 &size,
-                                 &fsamplerate);
+  r = AudioObjectGetPropertyData(output_device_id, &samplerate_address, 0, NULL,
+                                 &size, &fsamplerate);
 
   if (r != noErr) {
     return CUBEB_ERROR;
@@ -1325,7 +1343,8 @@ audiounit_convert_channel_layout(AudioChannelLayout * layout)
     return CUBEB_LAYOUT_STEREO;
   }
 
-  if (layout->mChannelLayoutTag != kAudioChannelLayoutTag_UseChannelDescriptions) {
+  if (layout->mChannelLayoutTag !=
+      kAudioChannelLayoutTag_UseChannelDescriptions) {
     // kAudioChannelLayoutTag_UseChannelBitmap
     // kAudioChannelLayoutTag_Mono
     // kAudioChannelLayoutTag_Stereo
@@ -1337,7 +1356,7 @@ audiounit_convert_channel_layout(AudioChannelLayout * layout)
   cubeb_channel_layout cl = 0;
   for (UInt32 i = 0; i < layout->mNumberChannelDescriptions; ++i) {
     cubeb_channel cc = channel_label_to_cubeb_channel(
-      layout->mChannelDescriptions[i].mChannelLabel);
+        layout->mChannelDescriptions[i].mChannelLabel);
     if (cc == CHANNEL_UNKNOWN) {
       return CUBEB_LAYOUT_UNDEFINED;
     }
@@ -1352,27 +1371,24 @@ audiounit_get_preferred_channel_layout(AudioUnit output_unit)
 {
   OSStatus rv = noErr;
   UInt32 size = 0;
-  rv = AudioUnitGetPropertyInfo(output_unit,
-                                kAudioDevicePropertyPreferredChannelLayout,
-                                kAudioUnitScope_Output,
-                                AU_OUT_BUS,
-                                &size,
-                                nullptr);
+  rv = AudioUnitGetPropertyInfo(
+      output_unit, kAudioDevicePropertyPreferredChannelLayout,
+      kAudioUnitScope_Output, AU_OUT_BUS, &size, nullptr);
   if (rv != noErr) {
-    LOG("AudioUnitGetPropertyInfo/kAudioDevicePropertyPreferredChannelLayout rv=%d", rv);
+    LOG("AudioUnitGetPropertyInfo/kAudioDevicePropertyPreferredChannelLayout "
+        "rv=%d",
+        rv);
     return CUBEB_LAYOUT_UNDEFINED;
   }
   assert(size > 0);
 
   auto layout = make_sized_audio_channel_layout(size);
-  rv = AudioUnitGetProperty(output_unit,
-                            kAudioDevicePropertyPreferredChannelLayout,
-                            kAudioUnitScope_Output,
-                            AU_OUT_BUS,
-                            layout.get(),
-                            &size);
+  rv = AudioUnitGetProperty(
+      output_unit, kAudioDevicePropertyPreferredChannelLayout,
+      kAudioUnitScope_Output, AU_OUT_BUS, layout.get(), &size);
   if (rv != noErr) {
-    LOG("AudioUnitGetProperty/kAudioDevicePropertyPreferredChannelLayout rv=%d", rv);
+    LOG("AudioUnitGetProperty/kAudioDevicePropertyPreferredChannelLayout rv=%d",
+        rv);
     return CUBEB_LAYOUT_UNDEFINED;
   }
 
@@ -1384,25 +1400,20 @@ audiounit_get_current_channel_layout(AudioUnit output_unit)
 {
   OSStatus rv = noErr;
   UInt32 size = 0;
-  rv = AudioUnitGetPropertyInfo(output_unit,
-                                kAudioUnitProperty_AudioChannelLayout,
-                                kAudioUnitScope_Output,
-                                AU_OUT_BUS,
-                                &size,
-                                nullptr);
+  rv = AudioUnitGetPropertyInfo(
+      output_unit, kAudioUnitProperty_AudioChannelLayout,
+      kAudioUnitScope_Output, AU_OUT_BUS, &size, nullptr);
   if (rv != noErr) {
-    LOG("AudioUnitGetPropertyInfo/kAudioUnitProperty_AudioChannelLayout rv=%d", rv);
+    LOG("AudioUnitGetPropertyInfo/kAudioUnitProperty_AudioChannelLayout rv=%d",
+        rv);
     // This property isn't known before macOS 10.12, attempt another method.
     return audiounit_get_preferred_channel_layout(output_unit);
   }
   assert(size > 0);
 
   auto layout = make_sized_audio_channel_layout(size);
-  rv = AudioUnitGetProperty(output_unit,
-                            kAudioUnitProperty_AudioChannelLayout,
-                            kAudioUnitScope_Output,
-                            AU_OUT_BUS,
-                            layout.get(),
+  rv = AudioUnitGetProperty(output_unit, kAudioUnitProperty_AudioChannelLayout,
+                            kAudioUnitScope_Output, AU_OUT_BUS, layout.get(),
                             &size);
   if (rv != noErr) {
     LOG("AudioUnitGetProperty/kAudioUnitProperty_AudioChannelLayout rv=%d", rv);
@@ -1412,9 +1423,11 @@ audiounit_get_current_channel_layout(AudioUnit output_unit)
   return audiounit_convert_channel_layout(layout.get());
 }
 
-static int audiounit_create_unit(AudioUnit * unit, device_info * device);
+static int
+audiounit_create_unit(AudioUnit * unit, device_info * device);
 
-static OSStatus audiounit_remove_device_listener(cubeb * context, cubeb_device_type devtype);
+static OSStatus
+audiounit_remove_device_listener(cubeb * context, cubeb_device_type devtype);
 
 static void
 audiounit_destroy(cubeb * ctx)
@@ -1425,7 +1438,8 @@ audiounit_destroy(cubeb * ctx)
     // Disabling this assert for bug 1083664 -- we seem to leak a stream
     // assert(ctx->active_streams == 0);
     if (audiounit_active_streams(ctx) > 0) {
-      LOG("(%p) API misuse, %d streams active when context destroyed!", ctx, audiounit_active_streams(ctx));
+      LOG("(%p) API misuse, %d streams active when context destroyed!", ctx,
+          audiounit_active_streams(ctx));
     }
 
     /* Unregister the callback if necessary. */
@@ -1442,7 +1456,8 @@ audiounit_destroy(cubeb * ctx)
   delete ctx;
 }
 
-static void audiounit_stream_destroy(cubeb_stream * stm);
+static void
+audiounit_stream_destroy(cubeb_stream * stm);
 
 static int
 audio_stream_desc_init(AudioStreamBasicDescription * ss,
@@ -1455,8 +1470,8 @@ audio_stream_desc_init(AudioStreamBasicDescription * ss,
     break;
   case CUBEB_SAMPLE_S16BE:
     ss->mBitsPerChannel = 16;
-    ss->mFormatFlags = kAudioFormatFlagIsSignedInteger |
-      kAudioFormatFlagIsBigEndian;
+    ss->mFormatFlags =
+        kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsBigEndian;
     break;
   case CUBEB_SAMPLE_FLOAT32LE:
     ss->mBitsPerChannel = 32;
@@ -1464,8 +1479,7 @@ audio_stream_desc_init(AudioStreamBasicDescription * ss,
     break;
   case CUBEB_SAMPLE_FLOAT32BE:
     ss->mBitsPerChannel = 32;
-    ss->mFormatFlags = kAudioFormatFlagIsFloat |
-      kAudioFormatFlagIsBigEndian;
+    ss->mFormatFlags = kAudioFormatFlagIsFloat | kAudioFormatFlagIsBigEndian;
     break;
   default:
     return CUBEB_ERROR_INVALID_FORMAT;
@@ -1491,17 +1505,15 @@ audiounit_init_mixer(cubeb_stream * stm)
   // We can't rely on macOS' AudioUnit to properly downmix (or upmix) the audio
   // data, it silently drop the channels so we need to remix the
   // audio data by ourselves to keep all the information.
-  stm->mixer.reset(cubeb_mixer_create(stm->output_stream_params.format,
-                                      stm->output_stream_params.channels,
-                                      stm->output_stream_params.layout,
-                                      stm->context->channels,
-                                      stm->context->layout));
+  stm->mixer.reset(cubeb_mixer_create(
+      stm->output_stream_params.format, stm->output_stream_params.channels,
+      stm->output_stream_params.layout, stm->context->channels,
+      stm->context->layout));
   assert(stm->mixer);
 }
 
 static int
-audiounit_set_channel_layout(AudioUnit unit,
-                             io_side side,
+audiounit_set_channel_layout(AudioUnit unit, io_side side,
                              cubeb_channel_layout layout)
 {
   if (side != io_side::OUTPUT) {
@@ -1513,7 +1525,6 @@ audiounit_set_channel_layout(AudioUnit unit,
     return CUBEB_OK;
   }
 
-
   OSStatus r;
   uint32_t nb_channels = cubeb_channel_layout_nb_channels(layout);
 
@@ -1531,21 +1542,20 @@ audiounit_set_channel_layout(AudioUnit unit,
     uint32_t channel = (channelMap & 1) << i;
     if (channel != 0) {
       au_layout->mChannelDescriptions[channels].mChannelLabel =
-        cubeb_channel_to_channel_label(static_cast<cubeb_channel>(channel));
-      au_layout->mChannelDescriptions[channels].mChannelFlags = kAudioChannelFlags_AllOff;
+          cubeb_channel_to_channel_label(static_cast<cubeb_channel>(channel));
+      au_layout->mChannelDescriptions[channels].mChannelFlags =
+          kAudioChannelFlags_AllOff;
       channels++;
     }
     channelMap = channelMap >> 1;
   }
 
-  r = AudioUnitSetProperty(unit,
-                           kAudioUnitProperty_AudioChannelLayout,
-                           kAudioUnitScope_Input,
-                           AU_OUT_BUS,
-                           au_layout.get(),
+  r = AudioUnitSetProperty(unit, kAudioUnitProperty_AudioChannelLayout,
+                           kAudioUnitScope_Input, AU_OUT_BUS, au_layout.get(),
                            size);
   if (r != noErr) {
-    LOG("AudioUnitSetProperty/%s/kAudioUnitProperty_AudioChannelLayout rv=%d", to_string(side), r);
+    LOG("AudioUnitSetProperty/%s/kAudioUnitProperty_AudioChannelLayout rv=%d",
+        to_string(side), r);
     return CUBEB_ERROR;
   }
 
@@ -1562,22 +1572,20 @@ audiounit_layout_init(cubeb_stream * stm, io_side side)
 
   stm->context->layout = audiounit_get_current_channel_layout(stm->output_unit);
 
-  audiounit_set_channel_layout(stm->output_unit, io_side::OUTPUT, stm->context->layout);
+  audiounit_set_channel_layout(stm->output_unit, io_side::OUTPUT,
+                               stm->context->layout);
 }
 
 static vector<AudioObjectID>
 audiounit_get_sub_devices(AudioDeviceID device_id)
 {
   vector<AudioDeviceID> sub_devices;
-  AudioObjectPropertyAddress property_address = { kAudioAggregateDevicePropertyActiveSubDeviceList,
-                                                  kAudioObjectPropertyScopeGlobal,
-                                                  kAudioObjectPropertyElementMaster };
+  AudioObjectPropertyAddress property_address = {
+      kAudioAggregateDevicePropertyActiveSubDeviceList,
+      kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster};
   UInt32 size = 0;
-  OSStatus rv = AudioObjectGetPropertyDataSize(device_id,
-                                               &property_address,
-                                               0,
-                                               nullptr,
-                                               &size);
+  OSStatus rv = AudioObjectGetPropertyDataSize(device_id, &property_address, 0,
+                                               nullptr, &size);
 
   if (rv != noErr) {
     sub_devices.push_back(device_id);
@@ -1586,12 +1594,8 @@ audiounit_get_sub_devices(AudioDeviceID device_id)
 
   uint32_t count = static_cast<uint32_t>(size / sizeof(AudioObjectID));
   sub_devices.resize(count);
-  rv = AudioObjectGetPropertyData(device_id,
-                                  &property_address,
-                                  0,
-                                  nullptr,
-                                  &size,
-                                  sub_devices.data());
+  rv = AudioObjectGetPropertyData(device_id, &property_address, 0, nullptr,
+                                  &size, sub_devices.data());
   if (rv != noErr) {
     sub_devices.clear();
     sub_devices.push_back(device_id);
@@ -1602,18 +1606,19 @@ audiounit_get_sub_devices(AudioDeviceID device_id)
 }
 
 static int
-audiounit_create_blank_aggregate_device(AudioObjectID * plugin_id, AudioDeviceID * aggregate_device_id)
+audiounit_create_blank_aggregate_device(AudioObjectID * plugin_id,
+                                        AudioDeviceID * aggregate_device_id)
 {
-  AudioObjectPropertyAddress address_plugin_bundle_id = { kAudioHardwarePropertyPlugInForBundleID,
-                                                          kAudioObjectPropertyScopeGlobal,
-                                                          kAudioObjectPropertyElementMaster };
+  AudioObjectPropertyAddress address_plugin_bundle_id = {
+      kAudioHardwarePropertyPlugInForBundleID, kAudioObjectPropertyScopeGlobal,
+      kAudioObjectPropertyElementMaster};
   UInt32 size = 0;
-  OSStatus r = AudioObjectGetPropertyDataSize(kAudioObjectSystemObject,
-                                              &address_plugin_bundle_id,
-                                              0, NULL,
-                                              &size);
+  OSStatus r = AudioObjectGetPropertyDataSize(
+      kAudioObjectSystemObject, &address_plugin_bundle_id, 0, NULL, &size);
   if (r != noErr) {
-    LOG("AudioObjectGetPropertyDataSize/kAudioHardwarePropertyPlugInForBundleID, rv=%d", r);
+    LOG("AudioObjectGetPropertyDataSize/"
+        "kAudioHardwarePropertyPlugInForBundleID, rv=%d",
+        r);
     return CUBEB_ERROR;
   }
 
@@ -1625,62 +1630,72 @@ audiounit_create_blank_aggregate_device(AudioObjectID * plugin_id, AudioDeviceID
   translation_value.mOutputDataSize = sizeof(*plugin_id);
 
   r = AudioObjectGetPropertyData(kAudioObjectSystemObject,
-                                 &address_plugin_bundle_id,
-                                 0,
-                                 nullptr,
-                                 &size,
+                                 &address_plugin_bundle_id, 0, nullptr, &size,
                                  &translation_value);
   if (r != noErr) {
-    LOG("AudioObjectGetPropertyData/kAudioHardwarePropertyPlugInForBundleID, rv=%d", r);
+    LOG("AudioObjectGetPropertyData/kAudioHardwarePropertyPlugInForBundleID, "
+        "rv=%d",
+        r);
     return CUBEB_ERROR;
   }
 
-  AudioObjectPropertyAddress create_aggregate_device_address = { kAudioPlugInCreateAggregateDevice,
-                                                                 kAudioObjectPropertyScopeGlobal,
-                                                                 kAudioObjectPropertyElementMaster };
-  r = AudioObjectGetPropertyDataSize(*plugin_id,
-                                     &create_aggregate_device_address,
-                                     0,
-                                     nullptr,
-                                     &size);
+  AudioObjectPropertyAddress create_aggregate_device_address = {
+      kAudioPlugInCreateAggregateDevice, kAudioObjectPropertyScopeGlobal,
+      kAudioObjectPropertyElementMaster};
+  r = AudioObjectGetPropertyDataSize(
+      *plugin_id, &create_aggregate_device_address, 0, nullptr, &size);
   if (r != noErr) {
-    LOG("AudioObjectGetPropertyDataSize/kAudioPlugInCreateAggregateDevice, rv=%d", r);
+    LOG("AudioObjectGetPropertyDataSize/kAudioPlugInCreateAggregateDevice, "
+        "rv=%d",
+        r);
     return CUBEB_ERROR;
   }
 
-  CFMutableDictionaryRef aggregate_device_dict = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
-                                                                           &kCFTypeDictionaryKeyCallBacks,
-                                                                           &kCFTypeDictionaryValueCallBacks);
+  CFMutableDictionaryRef aggregate_device_dict = CFDictionaryCreateMutable(
+      kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks,
+      &kCFTypeDictionaryValueCallBacks);
   struct timeval timestamp;
   gettimeofday(&timestamp, NULL);
   long long int time_id = timestamp.tv_sec * 1000000LL + timestamp.tv_usec;
-  CFStringRef aggregate_device_name = CFStringCreateWithFormat(NULL, NULL, CFSTR("%s_%llx"), PRIVATE_AGGREGATE_DEVICE_NAME, time_id);
-  CFDictionaryAddValue(aggregate_device_dict, CFSTR(kAudioAggregateDeviceNameKey), aggregate_device_name);
+  CFStringRef aggregate_device_name = CFStringCreateWithFormat(
+      NULL, NULL, CFSTR("%s_%llx"), PRIVATE_AGGREGATE_DEVICE_NAME, time_id);
+  CFDictionaryAddValue(aggregate_device_dict,
+                       CFSTR(kAudioAggregateDeviceNameKey),
+                       aggregate_device_name);
   CFRelease(aggregate_device_name);
 
-  CFStringRef aggregate_device_UID = CFStringCreateWithFormat(NULL, NULL, CFSTR("org.mozilla.%s_%llx"), PRIVATE_AGGREGATE_DEVICE_NAME, time_id);
-  CFDictionaryAddValue(aggregate_device_dict, CFSTR(kAudioAggregateDeviceUIDKey), aggregate_device_UID);
+  CFStringRef aggregate_device_UID =
+      CFStringCreateWithFormat(NULL, NULL, CFSTR("org.mozilla.%s_%llx"),
+                               PRIVATE_AGGREGATE_DEVICE_NAME, time_id);
+  CFDictionaryAddValue(aggregate_device_dict,
+                       CFSTR(kAudioAggregateDeviceUIDKey),
+                       aggregate_device_UID);
   CFRelease(aggregate_device_UID);
 
   int private_value = 1;
-  CFNumberRef aggregate_device_private_key = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &private_value);
-  CFDictionaryAddValue(aggregate_device_dict, CFSTR(kAudioAggregateDeviceIsPrivateKey), aggregate_device_private_key);
+  CFNumberRef aggregate_device_private_key =
+      CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &private_value);
+  CFDictionaryAddValue(aggregate_device_dict,
+                       CFSTR(kAudioAggregateDeviceIsPrivateKey),
+                       aggregate_device_private_key);
   CFRelease(aggregate_device_private_key);
 
   int stacked_value = 0;
-  CFNumberRef aggregate_device_stacked_key = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &stacked_value);
-  CFDictionaryAddValue(aggregate_device_dict, CFSTR(kAudioAggregateDeviceIsStackedKey), aggregate_device_stacked_key);
+  CFNumberRef aggregate_device_stacked_key =
+      CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &stacked_value);
+  CFDictionaryAddValue(aggregate_device_dict,
+                       CFSTR(kAudioAggregateDeviceIsStackedKey),
+                       aggregate_device_stacked_key);
   CFRelease(aggregate_device_stacked_key);
 
-  r = AudioObjectGetPropertyData(*plugin_id,
-                                 &create_aggregate_device_address,
+  r = AudioObjectGetPropertyData(*plugin_id, &create_aggregate_device_address,
                                  sizeof(aggregate_device_dict),
-                                 &aggregate_device_dict,
-                                 &size,
+                                 &aggregate_device_dict, &size,
                                  aggregate_device_id);
   CFRelease(aggregate_device_dict);
   if (r != noErr) {
-    LOG("AudioObjectGetPropertyData/kAudioPlugInCreateAggregateDevice, rv=%d", r);
+    LOG("AudioObjectGetPropertyData/kAudioPlugInCreateAggregateDevice, rv=%d",
+        r);
     return CUBEB_ERROR;
   }
   LOG("New aggregate device %u", *aggregate_device_id);
@@ -1696,10 +1711,11 @@ get_device_name(AudioDeviceID id)
 {
   UInt32 size = sizeof(CFStringRef);
   CFStringRef UIname = nullptr;
-  AudioObjectPropertyAddress address_uuid = { kAudioDevicePropertyDeviceUID,
-                                              kAudioObjectPropertyScopeGlobal,
-                                              kAudioObjectPropertyElementMaster };
-  OSStatus err = AudioObjectGetPropertyData(id, &address_uuid, 0, nullptr, &size, &UIname);
+  AudioObjectPropertyAddress address_uuid = {kAudioDevicePropertyDeviceUID,
+                                             kAudioObjectPropertyScopeGlobal,
+                                             kAudioObjectPropertyElementMaster};
+  OSStatus err =
+      AudioObjectGetPropertyData(id, &address_uuid, 0, nullptr, &size, &UIname);
   return (err == noErr) ? UIname : NULL;
 }
 
@@ -1710,12 +1726,15 @@ audiounit_set_aggregate_sub_device_list(AudioDeviceID aggregate_device_id,
 {
   LOG("Add devices input %u and output %u into aggregate device %u",
       input_device_id, output_device_id, aggregate_device_id);
-  const vector<AudioDeviceID> output_sub_devices = audiounit_get_sub_devices(output_device_id);
-  const vector<AudioDeviceID> input_sub_devices = audiounit_get_sub_devices(input_device_id);
-
-  CFMutableArrayRef aggregate_sub_devices_array = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
-  /* The order of the items in the array is significant and is used to determine the order of the streams
-     of the AudioAggregateDevice. */
+  const vector<AudioDeviceID> output_sub_devices =
+      audiounit_get_sub_devices(output_device_id);
+  const vector<AudioDeviceID> input_sub_devices =
+      audiounit_get_sub_devices(input_device_id);
+
+  CFMutableArrayRef aggregate_sub_devices_array =
+      CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
+  /* The order of the items in the array is significant and is used to determine
+     the order of the streams of the AudioAggregateDevice. */
   for (UInt32 i = 0; i < output_sub_devices.size(); i++) {
     CFStringRef ref = get_device_name(output_sub_devices[i]);
     if (ref == NULL) {
@@ -1735,19 +1754,18 @@ audiounit_set_aggregate_sub_device_list(AudioDeviceID aggregate_device_id,
     CFRelease(ref);
   }
 
-  AudioObjectPropertyAddress aggregate_sub_device_list = { kAudioAggregateDevicePropertyFullSubDeviceList,
-                                                           kAudioObjectPropertyScopeGlobal,
-                                                           kAudioObjectPropertyElementMaster };
+  AudioObjectPropertyAddress aggregate_sub_device_list = {
+      kAudioAggregateDevicePropertyFullSubDeviceList,
+      kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster};
   UInt32 size = sizeof(CFMutableArrayRef);
-  OSStatus rv = AudioObjectSetPropertyData(aggregate_device_id,
-                                           &aggregate_sub_device_list,
-                                           0,
-                                           nullptr,
-                                           size,
-                                           &aggregate_sub_devices_array);
+  OSStatus rv = AudioObjectSetPropertyData(
+      aggregate_device_id, &aggregate_sub_device_list, 0, nullptr, size,
+      &aggregate_sub_devices_array);
   CFRelease(aggregate_sub_devices_array);
   if (rv != noErr) {
-    LOG("AudioObjectSetPropertyData/kAudioAggregateDevicePropertyFullSubDeviceList, rv=%d", rv);
+    LOG("AudioObjectSetPropertyData/"
+        "kAudioAggregateDevicePropertyFullSubDeviceList, rv=%d",
+        rv);
     return CUBEB_ERROR;
   }
 
@@ -1758,27 +1776,28 @@ static int
 audiounit_set_master_aggregate_device(const AudioDeviceID aggregate_device_id)
 {
   assert(aggregate_device_id != kAudioObjectUnknown);
-  AudioObjectPropertyAddress master_aggregate_sub_device =  { kAudioAggregateDevicePropertyMasterSubDevice,
-                                                              kAudioObjectPropertyScopeGlobal,
-                                                              kAudioObjectPropertyElementMaster };
+  AudioObjectPropertyAddress master_aggregate_sub_device = {
+      kAudioAggregateDevicePropertyMasterSubDevice,
+      kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster};
 
   // Master become the 1st output sub device
-  AudioDeviceID output_device_id = audiounit_get_default_device_id(CUBEB_DEVICE_TYPE_OUTPUT);
-  const vector<AudioDeviceID> output_sub_devices = audiounit_get_sub_devices(output_device_id);
+  AudioDeviceID output_device_id =
+      audiounit_get_default_device_id(CUBEB_DEVICE_TYPE_OUTPUT);
+  const vector<AudioDeviceID> output_sub_devices =
+      audiounit_get_sub_devices(output_device_id);
   CFStringRef master_sub_device = get_device_name(output_sub_devices[0]);
 
   UInt32 size = sizeof(CFStringRef);
   OSStatus rv = AudioObjectSetPropertyData(aggregate_device_id,
-                                           &master_aggregate_sub_device,
-                                           0,
-                                           NULL,
-                                           size,
-                                           &master_sub_device);
+                                           &master_aggregate_sub_device, 0,
+                                           NULL, size, &master_sub_device);
   if (master_sub_device) {
     CFRelease(master_sub_device);
   }
   if (rv != noErr) {
-    LOG("AudioObjectSetPropertyData/kAudioAggregateDevicePropertyMasterSubDevice, rv=%d", rv);
+    LOG("AudioObjectSetPropertyData/"
+        "kAudioAggregateDevicePropertyMasterSubDevice, rv=%d",
+        rv);
     return CUBEB_ERROR;
   }
 
@@ -1786,24 +1805,25 @@ audiounit_set_master_aggregate_device(const AudioDeviceID aggregate_device_id)
 }
 
 static int
-audiounit_activate_clock_drift_compensation(const AudioDeviceID aggregate_device_id)
+audiounit_activate_clock_drift_compensation(
+    const AudioDeviceID aggregate_device_id)
 {
   assert(aggregate_device_id != kAudioObjectUnknown);
-  AudioObjectPropertyAddress address_owned = { kAudioObjectPropertyOwnedObjects,
-                                               kAudioObjectPropertyScopeGlobal,
-                                               kAudioObjectPropertyElementMaster };
+  AudioObjectPropertyAddress address_owned = {
+      kAudioObjectPropertyOwnedObjects, kAudioObjectPropertyScopeGlobal,
+      kAudioObjectPropertyElementMaster};
 
   UInt32 qualifier_data_size = sizeof(AudioObjectID);
   AudioClassID class_id = kAudioSubDeviceClassID;
   void * qualifier_data = &class_id;
   UInt32 size = 0;
-  OSStatus rv = AudioObjectGetPropertyDataSize(aggregate_device_id,
-                                               &address_owned,
-                                               qualifier_data_size,
-                                               qualifier_data,
-                                               &size);
+  OSStatus rv = AudioObjectGetPropertyDataSize(
+      aggregate_device_id, &address_owned, qualifier_data_size, qualifier_data,
+      &size);
   if (rv != noErr) {
-    LOG("AudioObjectGetPropertyDataSize/kAudioObjectPropertyOwnedObjects, rv=%d", rv);
+    LOG("AudioObjectGetPropertyDataSize/kAudioObjectPropertyOwnedObjects, "
+        "rv=%d",
+        rv);
     return CUBEB_ERROR;
   }
 
@@ -1812,87 +1832,95 @@ audiounit_activate_clock_drift_compensation(const AudioDeviceID aggregate_device
   AudioObjectID sub_devices[subdevices_num];
   size = sizeof(sub_devices);
 
-  rv = AudioObjectGetPropertyData(aggregate_device_id,
-                                  &address_owned,
-                                  qualifier_data_size,
-                                  qualifier_data,
-                                  &size,
+  rv = AudioObjectGetPropertyData(aggregate_device_id, &address_owned,
+                                  qualifier_data_size, qualifier_data, &size,
                                   sub_devices);
   if (rv != noErr) {
-    LOG("AudioObjectGetPropertyData/kAudioObjectPropertyOwnedObjects, rv=%d", rv);
+    LOG("AudioObjectGetPropertyData/kAudioObjectPropertyOwnedObjects, rv=%d",
+        rv);
     return CUBEB_ERROR;
   }
 
-  AudioObjectPropertyAddress address_drift = { kAudioSubDevicePropertyDriftCompensation,
-                                               kAudioObjectPropertyScopeGlobal,
-                                               kAudioObjectPropertyElementMaster };
+  AudioObjectPropertyAddress address_drift = {
+      kAudioSubDevicePropertyDriftCompensation, kAudioObjectPropertyScopeGlobal,
+      kAudioObjectPropertyElementMaster};
 
   // Start from the second device since the first is the master clock
   for (UInt32 i = 1; i < subdevices_num; ++i) {
     UInt32 drift_compensation_value = 1;
-    rv = AudioObjectSetPropertyData(sub_devices[i],
-                                    &address_drift,
-                                    0,
-                                    nullptr,
-                                    sizeof(UInt32),
-                                    &drift_compensation_value);
+    rv = AudioObjectSetPropertyData(sub_devices[i], &address_drift, 0, nullptr,
+                                    sizeof(UInt32), &drift_compensation_value);
     if (rv != noErr) {
-      LOG("AudioObjectSetPropertyData/kAudioSubDevicePropertyDriftCompensation, rv=%d", rv);
+      LOG("AudioObjectSetPropertyData/"
+          "kAudioSubDevicePropertyDriftCompensation, rv=%d",
+          rv);
       return CUBEB_OK;
     }
   }
   return CUBEB_OK;
 }
 
-static int audiounit_destroy_aggregate_device(AudioObjectID plugin_id, AudioDeviceID * aggregate_device_id);
-static void audiounit_get_available_samplerate(AudioObjectID devid, AudioObjectPropertyScope scope,
-                                   uint32_t * min, uint32_t * max, uint32_t * def);
 static int
-audiounit_create_device_from_hwdev(cubeb_device_info * dev_info, AudioObjectID devid, cubeb_device_type type);
-static void audiounit_device_destroy(cubeb_device_info * device);
+audiounit_destroy_aggregate_device(AudioObjectID plugin_id,
+                                   AudioDeviceID * aggregate_device_id);
+static void
+audiounit_get_available_samplerate(AudioObjectID devid,
+                                   AudioObjectPropertyScope scope,
+                                   uint32_t * min, uint32_t * max,
+                                   uint32_t * def);
+static int
+audiounit_create_device_from_hwdev(cubeb_device_info * dev_info,
+                                   AudioObjectID devid, cubeb_device_type type);
+static void
+audiounit_device_destroy(cubeb_device_info * device);
 
 static void
 audiounit_workaround_for_airpod(cubeb_stream * stm)
 {
   cubeb_device_info input_device_info;
-  audiounit_create_device_from_hwdev(&input_device_info, stm->input_device.id, CUBEB_DEVICE_TYPE_INPUT);
+  audiounit_create_device_from_hwdev(&input_device_info, stm->input_device.id,
+                                     CUBEB_DEVICE_TYPE_INPUT);
 
   cubeb_device_info output_device_info;
-  audiounit_create_device_from_hwdev(&output_device_info, stm->output_device.id, CUBEB_DEVICE_TYPE_OUTPUT);
+  audiounit_create_device_from_hwdev(&output_device_info, stm->output_device.id,
+                                     CUBEB_DEVICE_TYPE_OUTPUT);
 
   std::string input_name_str(input_device_info.friendly_name);
   std::string output_name_str(output_device_info.friendly_name);
 
-  if(input_name_str.find("AirPods") != std::string::npos &&
-     output_name_str.find("AirPods") != std::string::npos) {
+  if (input_name_str.find("AirPods") != std::string::npos &&
+      output_name_str.find("AirPods") != std::string::npos) {
     uint32_t input_min_rate = 0;
     uint32_t input_max_rate = 0;
     uint32_t input_nominal_rate = 0;
-    audiounit_get_available_samplerate(stm->input_device.id, kAudioObjectPropertyScopeGlobal,
-                                       &input_min_rate, &input_max_rate, &input_nominal_rate);
-    LOG("(%p) Input device %u, name: %s, min: %u, max: %u, nominal rate: %u", stm, stm->input_device.id
-    , input_device_info.friendly_name, input_min_rate, input_max_rate, input_nominal_rate);
+    audiounit_get_available_samplerate(
+        stm->input_device.id, kAudioObjectPropertyScopeGlobal, &input_min_rate,
+        &input_max_rate, &input_nominal_rate);
+    LOG("(%p) Input device %u, name: %s, min: %u, max: %u, nominal rate: %u",
+        stm, stm->input_device.id, input_device_info.friendly_name,
+        input_min_rate, input_max_rate, input_nominal_rate);
     uint32_t output_min_rate = 0;
     uint32_t output_max_rate = 0;
     uint32_t output_nominal_rate = 0;
-    audiounit_get_available_samplerate(stm->output_device.id, kAudioObjectPropertyScopeGlobal,
-                                       &output_min_rate, &output_max_rate, &output_nominal_rate);
-    LOG("(%p) Output device %u, name: %s, min: %u, max: %u, nominal rate: %u", stm, stm->output_device.id
-    , output_device_info.friendly_name, output_min_rate, output_max_rate, output_nominal_rate);
+    audiounit_get_available_samplerate(
+        stm->output_device.id, kAudioObjectPropertyScopeGlobal,
+        &output_min_rate, &output_max_rate, &output_nominal_rate);
+    LOG("(%p) Output device %u, name: %s, min: %u, max: %u, nominal rate: %u",
+        stm, stm->output_device.id, output_device_info.friendly_name,
+        output_min_rate, output_max_rate, output_nominal_rate);
 
     Float64 rate = input_nominal_rate;
     AudioObjectPropertyAddress addr = {kAudioDevicePropertyNominalSampleRate,
                                        kAudioObjectPropertyScopeGlobal,
                                        kAudioObjectPropertyElementMaster};
 
-    OSStatus rv = AudioObjectSetPropertyData(stm->aggregate_device_id,
-                                             &addr,
-                                             0,
-                                             nullptr,
-                                             sizeof(Float64),
-                                             &rate);
+    OSStatus rv = AudioObjectSetPropertyData(stm->aggregate_device_id, &addr, 0,
+                                             nullptr, sizeof(Float64), &rate);
     if (rv != noErr) {
-      LOG("Non fatal error, AudioObjectSetPropertyData/kAudioDevicePropertyNominalSampleRate, rv=%d", rv);
+      LOG("Non fatal error, "
+          "AudioObjectSetPropertyData/kAudioDevicePropertyNominalSampleRate, "
+          "rv=%d",
+          rv);
     }
   }
   audiounit_device_destroy(&input_device_info);
@@ -1900,10 +1928,11 @@ audiounit_workaround_for_airpod(cubeb_stream * stm)
 }
 
 /*
- * Aggregate Device is a virtual audio interface which utilizes inputs and outputs
- * of one or more physical audio interfaces. It is possible to use the clock of
- * one of the devices as a master clock for all the combined devices and enable
- * drift compensation for the devices that are not designated clock master.
+ * Aggregate Device is a virtual audio interface which utilizes inputs and
+ * outputs of one or more physical audio interfaces. It is possible to use the
+ * clock of one of the devices as a master clock for all the combined devices
+ * and enable drift compensation for the devices that are not designated clock
+ * master.
  *
  * Creating a new aggregate device programmatically requires [0][1]:
  * 1. Locate the base plug-in ("com.apple.audio.CoreAudio")
@@ -1921,31 +1950,37 @@ audiounit_workaround_for_airpod(cubeb_stream * stm)
 static int
 audiounit_create_aggregate_device(cubeb_stream * stm)
 {
-  int r = audiounit_create_blank_aggregate_device(&stm->plugin_id, &stm->aggregate_device_id);
+  int r = audiounit_create_blank_aggregate_device(&stm->plugin_id,
+                                                  &stm->aggregate_device_id);
   if (r != CUBEB_OK) {
     LOG("(%p) Failed to create blank aggregate device", stm);
     return CUBEB_ERROR;
   }
 
-  r = audiounit_set_aggregate_sub_device_list(stm->aggregate_device_id, stm->input_device.id, stm->output_device.id);
+  r = audiounit_set_aggregate_sub_device_list(
+      stm->aggregate_device_id, stm->input_device.id, stm->output_device.id);
   if (r != CUBEB_OK) {
     LOG("(%p) Failed to set aggregate sub-device list", stm);
-    audiounit_destroy_aggregate_device(stm->plugin_id, &stm->aggregate_device_id);
+    audiounit_destroy_aggregate_device(stm->plugin_id,
+                                       &stm->aggregate_device_id);
     return CUBEB_ERROR;
   }
 
   r = audiounit_set_master_aggregate_device(stm->aggregate_device_id);
   if (r != CUBEB_OK) {
     LOG("(%p) Failed to set master sub-device for aggregate device", stm);
-    audiounit_destroy_aggregate_device(stm->plugin_id, &stm->aggregate_device_id);
-    return  CUBEB_ERROR;
+    audiounit_destroy_aggregate_device(stm->plugin_id,
+                                       &stm->aggregate_device_id);
+    return CUBEB_ERROR;
   }
 
   r = audiounit_activate_clock_drift_compensation(stm->aggregate_device_id);
   if (r != CUBEB_OK) {
-    LOG("(%p) Failed to activate clock drift compensation for aggregate device", stm);
-    audiounit_destroy_aggregate_device(stm->plugin_id, &stm->aggregate_device_id);
-    return  CUBEB_ERROR;
+    LOG("(%p) Failed to activate clock drift compensation for aggregate device",
+        stm);
+    audiounit_destroy_aggregate_device(stm->plugin_id,
+                                       &stm->aggregate_device_id);
+    return CUBEB_ERROR;
   }
 
   audiounit_workaround_for_airpod(stm);
@@ -1954,33 +1989,29 @@ audiounit_create_aggregate_device(cubeb_stream * stm)
 }
 
 static int
-audiounit_destroy_aggregate_device(AudioObjectID plugin_id, AudioDeviceID * aggregate_device_id)
+audiounit_destroy_aggregate_device(AudioObjectID plugin_id,
+                                   AudioDeviceID * aggregate_device_id)
 {
-  assert(aggregate_device_id &&
-         *aggregate_device_id != kAudioDeviceUnknown &&
+  assert(aggregate_device_id && *aggregate_device_id != kAudioDeviceUnknown &&
          plugin_id != kAudioObjectUnknown);
-  AudioObjectPropertyAddress destroy_aggregate_device_addr = { kAudioPlugInDestroyAggregateDevice,
-                                                               kAudioObjectPropertyScopeGlobal,
-                                                               kAudioObjectPropertyElementMaster};
+  AudioObjectPropertyAddress destroy_aggregate_device_addr = {
+      kAudioPlugInDestroyAggregateDevice, kAudioObjectPropertyScopeGlobal,
+      kAudioObjectPropertyElementMaster};
   UInt32 size;
-  OSStatus rv = AudioObjectGetPropertyDataSize(plugin_id,
-                                               &destroy_aggregate_device_addr,
-                                               0,
-                                               NULL,
-                                               &size);
+  OSStatus rv = AudioObjectGetPropertyDataSize(
+      plugin_id, &destroy_aggregate_device_addr, 0, NULL, &size);
   if (rv != noErr) {
-    LOG("AudioObjectGetPropertyDataSize/kAudioPlugInDestroyAggregateDevice, rv=%d", rv);
+    LOG("AudioObjectGetPropertyDataSize/kAudioPlugInDestroyAggregateDevice, "
+        "rv=%d",
+        rv);
     return CUBEB_ERROR;
   }
 
-  rv = AudioObjectGetPropertyData(plugin_id,
-                                  &destroy_aggregate_device_addr,
-                                  0,
-                                  NULL,
-                                  &size,
-                                  aggregate_device_id);
+  rv = AudioObjectGetPropertyData(plugin_id, &destroy_aggregate_device_addr, 0,
+                                  NULL, &size, aggregate_device_id);
   if (rv != noErr) {
-    LOG("AudioObjectGetPropertyData/kAudioPlugInDestroyAggregateDevice, rv=%d", rv);
+    LOG("AudioObjectGetPropertyData/kAudioPlugInDestroyAggregateDevice, rv=%d",
+        rv);
     return CUBEB_ERROR;
   }
 
@@ -2004,8 +2035,7 @@ audiounit_new_unit_instance(AudioUnit * unit, device_info * device)
   // so we retain automatic output device switching when the default
   // changes.  Once we have complete support for device notifications
   // and switching, we can use the AUHAL for everything.
-  if ((device->flags & DEV_SYSTEM_DEFAULT) &&
-      (device->flags & DEV_OUTPUT)) {
+  if ((device->flags & DEV_SYSTEM_DEFAULT) && (device->flags & DEV_OUTPUT)) {
     desc.componentSubType = kAudioUnitSubType_DefaultOutput;
   } else {
     desc.componentSubType = kAudioUnitSubType_HALOutput;
@@ -2039,10 +2069,10 @@ audiounit_enable_unit_scope(AudioUnit * unit, io_side side, enable_state state)
   OSStatus rv;
   UInt32 enable = state;
   rv = AudioUnitSetProperty(*unit, kAudioOutputUnitProperty_EnableIO,
-                            (side == io_side::INPUT) ? kAudioUnitScope_Input : kAudioUnitScope_Output,
+                            (side == io_side::INPUT) ? kAudioUnitScope_Input
+                                                     : kAudioUnitScope_Output,
                             (side == io_side::INPUT) ? AU_IN_BUS : AU_OUT_BUS,
-                            &enable,
-                            sizeof(UInt32));
+                            &enable, sizeof(UInt32));
   if (rv != noErr) {
     LOG("AudioUnitSetProperty/kAudioOutputUnitProperty_EnableIO rv=%d", rv);
     return CUBEB_ERROR;
@@ -2065,12 +2095,10 @@ audiounit_create_unit(AudioUnit * unit, device_info * device)
   }
   assert(*unit);
 
-  if ((device->flags & DEV_SYSTEM_DEFAULT) &&
-      (device->flags & DEV_OUTPUT)) {
+  if ((device->flags & DEV_SYSTEM_DEFAULT) && (device->flags & DEV_OUTPUT)) {
     return CUBEB_OK;
   }
 
-
   if (device->flags & DEV_INPUT) {
     r = audiounit_enable_unit_scope(unit, io_side::INPUT, ENABLE);
     if (r != CUBEB_OK) {
@@ -2097,13 +2125,12 @@ audiounit_create_unit(AudioUnit * unit, device_info * device)
     assert(false);
   }
 
-  rv = AudioUnitSetProperty(*unit,
-                            kAudioOutputUnitProperty_CurrentDevice,
-                            kAudioUnitScope_Global,
-                            0,
-                            &device->id, sizeof(AudioDeviceID));
+  rv = AudioUnitSetProperty(*unit, kAudioOutputUnitProperty_CurrentDevice,
+                            kAudioUnitScope_Global, 0, &device->id,
+                            sizeof(AudioDeviceID));
   if (rv != noErr) {
-    LOG("AudioUnitSetProperty/kAudioOutputUnitProperty_CurrentDevice rv=%d", rv);
+    LOG("AudioUnitSetProperty/kAudioOutputUnitProperty_CurrentDevice rv=%d",
+        rv);
     return CUBEB_ERROR;
   }
 
@@ -2113,7 +2140,8 @@ audiounit_create_unit(AudioUnit * unit, device_info * device)
 static int
 audiounit_init_input_linear_buffer(cubeb_stream * stream, uint32_t capacity)
 {
-  uint32_t size = capacity * stream->latency_frames * stream->input_desc.mChannelsPerFrame;
+  uint32_t size =
+      capacity * stream->latency_frames * stream->input_desc.mChannelsPerFrame;
   if (stream->input_desc.mFormatFlags & kAudioFormatFlagIsSignedInteger) {
     stream->input_linear_buffer.reset(new auto_array_wrapper_impl<short>(size));
   } else {
@@ -2131,7 +2159,7 @@ audiounit_clamp_latency(cubeb_stream * stm, uint32_t latency_frames)
   assert(audiounit_active_streams(stm->context) > 0);
   if (audiounit_active_streams(stm->context) == 1) {
     return max(min<uint32_t>(latency_frames, SAFE_MAX_LATENCY_FRAMES),
-                    SAFE_MIN_LATENCY_FRAMES);
+               SAFE_MIN_LATENCY_FRAMES);
   }
   assert(stm->output_unit);
 
@@ -2141,36 +2169,36 @@ audiounit_clamp_latency(cubeb_stream * stm, uint32_t latency_frames)
   UInt32 output_buffer_size = 0;
   UInt32 size = sizeof(output_buffer_size);
   if (stm->output_unit) {
-    r = AudioUnitGetProperty(stm->output_unit,
-                            kAudioDevicePropertyBufferFrameSize,
-                            kAudioUnitScope_Output,
-                            AU_OUT_BUS,
-                            &output_buffer_size,
-                            &size);
+    r = AudioUnitGetProperty(
+        stm->output_unit, kAudioDevicePropertyBufferFrameSize,
+        kAudioUnitScope_Output, AU_OUT_BUS, &output_buffer_size, &size);
     if (r != noErr) {
-      LOG("AudioUnitGetProperty/output/kAudioDevicePropertyBufferFrameSize rv=%d", r);
+      LOG("AudioUnitGetProperty/output/kAudioDevicePropertyBufferFrameSize "
+          "rv=%d",
+          r);
       return 0;
     }
 
-    output_buffer_size = max(min<uint32_t>(output_buffer_size, SAFE_MAX_LATENCY_FRAMES),
-                                  SAFE_MIN_LATENCY_FRAMES);
+    output_buffer_size =
+        max(min<uint32_t>(output_buffer_size, SAFE_MAX_LATENCY_FRAMES),
+            SAFE_MIN_LATENCY_FRAMES);
   }
 
   UInt32 input_buffer_size = 0;
   if (stm->input_unit) {
-    r = AudioUnitGetProperty(stm->input_unit,
-                            kAudioDevicePropertyBufferFrameSize,
-                            kAudioUnitScope_Input,
-                            AU_IN_BUS,
-                            &input_buffer_size,
-                            &size);
+    r = AudioUnitGetProperty(
+        stm->input_unit, kAudioDevicePropertyBufferFrameSize,
+        kAudioUnitScope_Input, AU_IN_BUS, &input_buffer_size, &size);
     if (r != noErr) {
-      LOG("AudioUnitGetProperty/input/kAudioDevicePropertyBufferFrameSize rv=%d", r);
+      LOG("AudioUnitGetProperty/input/kAudioDevicePropertyBufferFrameSize "
+          "rv=%d",
+          r);
       return 0;
     }
 
-    input_buffer_size = max(min<uint32_t>(input_buffer_size, SAFE_MAX_LATENCY_FRAMES),
-                                 SAFE_MIN_LATENCY_FRAMES);
+    input_buffer_size =
+        max(min<uint32_t>(input_buffer_size, SAFE_MAX_LATENCY_FRAMES),
+            SAFE_MIN_LATENCY_FRAMES);
   }
 
   // Every following active streams can only set smaller latency
@@ -2186,7 +2214,7 @@ audiounit_clamp_latency(cubeb_stream * stm, uint32_t latency_frames)
   }
 
   return max(min<uint32_t>(latency_frames, upper_latency_limit),
-                  SAFE_MIN_LATENCY_FRAMES);
+             SAFE_MIN_LATENCY_FRAMES);
 }
 
 /*
@@ -2198,11 +2226,9 @@ audiounit_clamp_latency(cubeb_stream * stm, uint32_t latency_frames)
  * - property has changed, remove the listener
  * */
 static void
-buffer_size_changed_callback(void * inClientData,
-                             AudioUnit inUnit,
+buffer_size_changed_callback(void * inClientData, AudioUnit inUnit,
                              AudioUnitPropertyID inPropertyID,
-                             AudioUnitScope inScope,
-                             AudioUnitElement inElement)
+                             AudioUnitScope inScope, AudioUnitElement inElement)
 {
   cubeb_stream * stm = (cubeb_stream *)inClientData;
 
@@ -2218,32 +2244,33 @@ buffer_size_changed_callback(void * inClientData,
 
   switch (inPropertyID) {
 
-    case kAudioDevicePropertyBufferFrameSize: {
-      if (inScope != au_scope) {
-        break;
-      }
-      UInt32 new_buffer_size;
-      UInt32 outSize = sizeof(UInt32);
-      OSStatus r = AudioUnitGetProperty(au,
-                                        kAudioDevicePropertyBufferFrameSize,
-                                        au_scope,
-                                        au_element,
-                                        &new_buffer_size,
-                                        &outSize);
-      if (r != noErr) {
-        LOG("(%p) Event: kAudioDevicePropertyBufferFrameSize: Cannot get current buffer size", stm);
-      } else {
-        LOG("(%p) Event: kAudioDevicePropertyBufferFrameSize: New %s buffer size = %d for scope %d", stm,
-            au_type, new_buffer_size, inScope);
-      }
-      stm->buffer_size_change_state = true;
+  case kAudioDevicePropertyBufferFrameSize: {
+    if (inScope != au_scope) {
       break;
     }
+    UInt32 new_buffer_size;
+    UInt32 outSize = sizeof(UInt32);
+    OSStatus r =
+        AudioUnitGetProperty(au, kAudioDevicePropertyBufferFrameSize, au_scope,
+                             au_element, &new_buffer_size, &outSize);
+    if (r != noErr) {
+      LOG("(%p) Event: kAudioDevicePropertyBufferFrameSize: Cannot get current "
+          "buffer size",
+          stm);
+    } else {
+      LOG("(%p) Event: kAudioDevicePropertyBufferFrameSize: New %s buffer size "
+          "= %d for scope %d",
+          stm, au_type, new_buffer_size, inScope);
+    }
+    stm->buffer_size_change_state = true;
+    break;
+  }
   }
 }
 
 static int
-audiounit_set_buffer_size(cubeb_stream * stm, uint32_t new_size_frames, io_side side)
+audiounit_set_buffer_size(cubeb_stream * stm, uint32_t new_size_frames,
+                          io_side side)
 {
   AudioUnit au = stm->output_unit;
   AudioUnitScope au_scope = kAudioUnitScope_Input;
@@ -2257,48 +2284,45 @@ audiounit_set_buffer_size(cubeb_stream * stm, uint32_t new_size_frames, io_side
 
   uint32_t buffer_frames = 0;
   UInt32 size = sizeof(buffer_frames);
-  int r = AudioUnitGetProperty(au,
-                               kAudioDevicePropertyBufferFrameSize,
-                               au_scope,
-                               au_element,
-                               &buffer_frames,
-                               &size);
+  int r = AudioUnitGetProperty(au, kAudioDevicePropertyBufferFrameSize,
+                               au_scope, au_element, &buffer_frames, &size);
   if (r != noErr) {
-    LOG("AudioUnitGetProperty/%s/kAudioDevicePropertyBufferFrameSize rv=%d", to_string(side), r);
+    LOG("AudioUnitGetProperty/%s/kAudioDevicePropertyBufferFrameSize rv=%d",
+        to_string(side), r);
     return CUBEB_ERROR;
   }
 
   if (new_size_frames == buffer_frames) {
-    LOG("(%p) No need to update %s buffer size already %u frames", stm, to_string(side), buffer_frames);
+    LOG("(%p) No need to update %s buffer size already %u frames", stm,
+        to_string(side), buffer_frames);
     return CUBEB_OK;
   }
 
-  r = AudioUnitAddPropertyListener(au,
-                                   kAudioDevicePropertyBufferFrameSize,
-                                   buffer_size_changed_callback,
-                                   stm);
+  r = AudioUnitAddPropertyListener(au, kAudioDevicePropertyBufferFrameSize,
+                                   buffer_size_changed_callback, stm);
   if (r != noErr) {
-    LOG("AudioUnitAddPropertyListener/%s/kAudioDevicePropertyBufferFrameSize rv=%d", to_string(side), r);
+    LOG("AudioUnitAddPropertyListener/%s/kAudioDevicePropertyBufferFrameSize "
+        "rv=%d",
+        to_string(side), r);
     return CUBEB_ERROR;
   }
 
   stm->buffer_size_change_state = false;
 
-  r = AudioUnitSetProperty(au,
-                           kAudioDevicePropertyBufferFrameSize,
-                           au_scope,
-                           au_element,
-                           &new_size_frames,
+  r = AudioUnitSetProperty(au, kAudioDevicePropertyBufferFrameSize, au_scope,
+                           au_element, &new_size_frames,
                            sizeof(new_size_frames));
   if (r != noErr) {
-    LOG("AudioUnitSetProperty/%s/kAudioDevicePropertyBufferFrameSize rv=%d", to_string(side), r);
+    LOG("AudioUnitSetProperty/%s/kAudioDevicePropertyBufferFrameSize rv=%d",
+        to_string(side), r);
 
-    r = AudioUnitRemovePropertyListenerWithUserData(au,
-                                                    kAudioDevicePropertyBufferFrameSize,
-                                                    buffer_size_changed_callback,
-                                                    stm);
+    r = AudioUnitRemovePropertyListenerWithUserData(
+        au, kAudioDevicePropertyBufferFrameSize, buffer_size_changed_callback,
+        stm);
     if (r != noErr) {
-      LOG("AudioUnitAddPropertyListener/%s/kAudioDevicePropertyBufferFrameSize rv=%d", to_string(side), r);
+      LOG("AudioUnitAddPropertyListener/%s/kAudioDevicePropertyBufferFrameSize "
+          "rv=%d",
+          to_string(side), r);
     }
 
     return CUBEB_ERROR;
@@ -2309,18 +2333,21 @@ audiounit_set_buffer_size(cubeb_stream * stm, uint32_t new_size_frames, io_side
     struct timespec req, rem;
     req.tv_sec = 0;
     req.tv_nsec = 100000000L; // 0.1 sec
-    if (nanosleep(&req , &rem) < 0 ) {
-      LOG("(%p) Warning: nanosleep call failed or interrupted. Remaining time %ld nano secs \n", stm, rem.tv_nsec);
+    if (nanosleep(&req, &rem) < 0) {
+      LOG("(%p) Warning: nanosleep call failed or interrupted. Remaining time "
+          "%ld nano secs \n",
+          stm, rem.tv_nsec);
     }
     LOG("(%p) audiounit_set_buffer_size : wait count = %d", stm, count);
   }
 
-  r = AudioUnitRemovePropertyListenerWithUserData(au,
-                                                  kAudioDevicePropertyBufferFrameSize,
-                                                  buffer_size_changed_callback,
-                                                  stm);
+  r = AudioUnitRemovePropertyListenerWithUserData(
+      au, kAudioDevicePropertyBufferFrameSize, buffer_size_changed_callback,
+      stm);
   if (r != noErr) {
-    LOG("AudioUnitAddPropertyListener/%s/kAudioDevicePropertyBufferFrameSize rv=%d", to_string(side), r);
+    LOG("AudioUnitAddPropertyListener/%s/kAudioDevicePropertyBufferFrameSize "
+        "rv=%d",
+        to_string(side), r);
     return CUBEB_ERROR;
   }
 
@@ -2329,7 +2356,8 @@ audiounit_set_buffer_size(cubeb_stream * stm, uint32_t new_size_frames, io_side
     return CUBEB_ERROR;
   }
 
-  LOG("(%p) %s buffer size changed to %u frames.", stm, to_string(side), new_size_frames);
+  LOG("(%p) %s buffer size changed to %u frames.", stm, to_string(side),
+      new_size_frames);
   return CUBEB_OK;
 }
 
@@ -2342,18 +2370,16 @@ audiounit_configure_input(cubeb_stream * stm)
   UInt32 size;
   AURenderCallbackStruct aurcbs_in;
 
-  LOG("(%p) Opening input side: rate %u, channels %u, format %d, latency in frames %u.",
+  LOG("(%p) Opening input side: rate %u, channels %u, format %d, latency in "
+      "frames %u.",
       stm, stm->input_stream_params.rate, stm->input_stream_params.channels,
       stm->input_stream_params.format, stm->latency_frames);
 
   /* Get input device sample rate. */
   AudioStreamBasicDescription input_hw_desc;
   size = sizeof(AudioStreamBasicDescription);
-  r = AudioUnitGetProperty(stm->input_unit,
-                           kAudioUnitProperty_StreamFormat,
-                           kAudioUnitScope_Input,
-                           AU_IN_BUS,
-                           &input_hw_desc,
+  r = AudioUnitGetProperty(stm->input_unit, kAudioUnitProperty_StreamFormat,
+                           kAudioUnitScope_Input, AU_IN_BUS, &input_hw_desc,
                            &size);
   if (r != noErr) {
     LOG("AudioUnitGetProperty/input/kAudioUnitProperty_StreamFormat rv=%d", r);
@@ -2381,11 +2407,8 @@ audiounit_configure_input(cubeb_stream * stm)
      we will resample inside input callback. */
   src_desc.mSampleRate = stm->input_hw_rate;
 
-  r = AudioUnitSetProperty(stm->input_unit,
-                           kAudioUnitProperty_StreamFormat,
-                           kAudioUnitScope_Output,
-                           AU_IN_BUS,
-                           &src_desc,
+  r = AudioUnitSetProperty(stm->input_unit, kAudioUnitProperty_StreamFormat,
+                           kAudioUnitScope_Output, AU_IN_BUS, &src_desc,
                            sizeof(AudioStreamBasicDescription));
   if (r != noErr) {
     LOG("AudioUnitSetProperty/input/kAudioUnitProperty_StreamFormat rv=%d", r);
@@ -2393,14 +2416,13 @@ audiounit_configure_input(cubeb_stream * stm)
   }
 
   /* Frames per buffer in the input callback. */
-  r = AudioUnitSetProperty(stm->input_unit,
-                           kAudioUnitProperty_MaximumFramesPerSlice,
-                           kAudioUnitScope_Global,
-                           AU_IN_BUS,
-                           &stm->latency_frames,
-                           sizeof(UInt32));
+  r = AudioUnitSetProperty(
+      stm->input_unit, kAudioUnitProperty_MaximumFramesPerSlice,
+      kAudioUnitScope_Global, AU_IN_BUS, &stm->latency_frames, sizeof(UInt32));
   if (r != noErr) {
-    LOG("AudioUnitSetProperty/input/kAudioUnitProperty_MaximumFramesPerSlice rv=%d", r);
+    LOG("AudioUnitSetProperty/input/kAudioUnitProperty_MaximumFramesPerSlice "
+        "rv=%d",
+        r);
     return CUBEB_ERROR;
   }
 
@@ -2417,14 +2439,13 @@ audiounit_configure_input(cubeb_stream * stm)
   aurcbs_in.inputProc = audiounit_input_callback;
   aurcbs_in.inputProcRefCon = stm;
 
-  r = AudioUnitSetProperty(stm->input_unit,
-                           kAudioOutputUnitProperty_SetInputCallback,
-                           kAudioUnitScope_Global,
-                           AU_OUT_BUS,
-                           &aurcbs_in,
-                           sizeof(aurcbs_in));
+  r = AudioUnitSetProperty(
+      stm->input_unit, kAudioOutputUnitProperty_SetInputCallback,
+      kAudioUnitScope_Global, AU_OUT_BUS, &aurcbs_in, sizeof(aurcbs_in));
   if (r != noErr) {
-    LOG("AudioUnitSetProperty/input/kAudioOutputUnitProperty_SetInputCallback rv=%d", r);
+    LOG("AudioUnitSetProperty/input/kAudioOutputUnitProperty_SetInputCallback "
+        "rv=%d",
+        r);
     return CUBEB_ERROR;
   }
 
@@ -2444,8 +2465,8 @@ audiounit_configure_output(cubeb_stream * stm)
   AURenderCallbackStruct aurcbs_out;
   UInt32 size;
 
-
-  LOG("(%p) Opening output side: rate %u, channels %u, format %d, latency in frames %u.",
+  LOG("(%p) Opening output side: rate %u, channels %u, format %d, latency in "
+      "frames %u.",
       stm, stm->output_stream_params.rate, stm->output_stream_params.channels,
       stm->output_stream_params.format, stm->latency_frames);
 
@@ -2459,18 +2480,16 @@ audiounit_configure_output(cubeb_stream * stm)
   AudioStreamBasicDescription output_hw_desc;
   size = sizeof(AudioStreamBasicDescription);
   memset(&output_hw_desc, 0, size);
-  r = AudioUnitGetProperty(stm->output_unit,
-                           kAudioUnitProperty_StreamFormat,
-                           kAudioUnitScope_Output,
-                           AU_OUT_BUS,
-                           &output_hw_desc,
+  r = AudioUnitGetProperty(stm->output_unit, kAudioUnitProperty_StreamFormat,
+                           kAudioUnitScope_Output, AU_OUT_BUS, &output_hw_desc,
                            &size);
   if (r != noErr) {
     LOG("AudioUnitGetProperty/output/kAudioUnitProperty_StreamFormat rv=%d", r);
     return CUBEB_ERROR;
   }
   stm->output_hw_rate = output_hw_desc.mSampleRate;
-  LOG("(%p) Output device sampling rate: %.2f", stm, output_hw_desc.mSampleRate);
+  LOG("(%p) Output device sampling rate: %.2f", stm,
+      output_hw_desc.mSampleRate);
   stm->context->channels = output_hw_desc.mChannelsPerFrame;
 
   // Set the input layout to match the output device layout.
@@ -2486,16 +2505,13 @@ audiounit_configure_output(cubeb_stream * stm)
     stm->output_desc.mBytesPerFrame = (stm->output_desc.mBitsPerChannel / 8) *
                                       stm->output_desc.mChannelsPerFrame;
     stm->output_desc.mBytesPerPacket =
-      stm->output_desc.mBytesPerFrame * stm->output_desc.mFramesPerPacket;
+        stm->output_desc.mBytesPerFrame * stm->output_desc.mFramesPerPacket;
   } else {
     stm->mixer = nullptr;
   }
 
-  r = AudioUnitSetProperty(stm->output_unit,
-                           kAudioUnitProperty_StreamFormat,
-                           kAudioUnitScope_Input,
-                           AU_OUT_BUS,
-                           &stm->output_desc,
+  r = AudioUnitSetProperty(stm->output_unit, kAudioUnitProperty_StreamFormat,
+                           kAudioUnitScope_Input, AU_OUT_BUS, &stm->output_desc,
                            sizeof(AudioStreamBasicDescription));
   if (r != noErr) {
     LOG("AudioUnitSetProperty/output/kAudioUnitProperty_StreamFormat rv=%d", r);
@@ -2509,27 +2525,25 @@ audiounit_configure_output(cubeb_stream * stm)
   }
 
   /* Frames per buffer in the input callback. */
-  r = AudioUnitSetProperty(stm->output_unit,
-                           kAudioUnitProperty_MaximumFramesPerSlice,
-                           kAudioUnitScope_Global,
-                           AU_OUT_BUS,
-                           &stm->latency_frames,
-                           sizeof(UInt32));
+  r = AudioUnitSetProperty(
+      stm->output_unit, kAudioUnitProperty_MaximumFramesPerSlice,
+      kAudioUnitScope_Global, AU_OUT_BUS, &stm->latency_frames, sizeof(UInt32));
   if (r != noErr) {
-    LOG("AudioUnitSetProperty/output/kAudioUnitProperty_MaximumFramesPerSlice rv=%d", r);
+    LOG("AudioUnitSetProperty/output/kAudioUnitProperty_MaximumFramesPerSlice "
+        "rv=%d",
+        r);
     return CUBEB_ERROR;
   }
 
   aurcbs_out.inputProc = audiounit_output_callback;
   aurcbs_out.inputProcRefCon = stm;
-  r = AudioUnitSetProperty(stm->output_unit,
-                           kAudioUnitProperty_SetRenderCallback,
-                           kAudioUnitScope_Global,
-                           AU_OUT_BUS,
-                           &aurcbs_out,
-                           sizeof(aurcbs_out));
+  r = AudioUnitSetProperty(
+      stm->output_unit, kAudioUnitProperty_SetRenderCallback,
+      kAudioUnitScope_Global, AU_OUT_BUS, &aurcbs_out, sizeof(aurcbs_out));
   if (r != noErr) {
-    LOG("AudioUnitSetProperty/output/kAudioUnitProperty_SetRenderCallback rv=%d", r);
+    LOG("AudioUnitSetProperty/output/kAudioUnitProperty_SetRenderCallback "
+        "rv=%d",
+        r);
     return CUBEB_ERROR;
   }
 
@@ -2589,8 +2603,8 @@ audiounit_setup_stream(cubeb_stream * stm)
     }
   }
 
-  /* Latency cannot change if another stream is operating in parallel. In this case
-   * latency is set to the other stream value. */
+  /* Latency cannot change if another stream is operating in parallel. In this
+   * case latency is set to the other stream value. */
   if (audiounit_active_streams(stm->context) > 1) {
     LOG("(%p) More than one active stream, use global latency.", stm);
     stm->latency_frames = stm->context->global_latency_frames;
@@ -2656,7 +2670,7 @@ audiounit_setup_stream(cubeb_stream * stm)
       return CUBEB_ERROR;
     }
   }
-#else  // TARGET_OS_IPHONE
+#else // TARGET_OS_IPHONE
   //TODO: [[AVAudioSession sharedInstance] inputLatency]
   // http://stackoverflow.com/questions/13157523/kaudiodevicepropertybufferframesize-replacement-for-ios
 #endif
@@ -2683,13 +2697,10 @@ audiounit_setup_stream(cubeb_stream * stm)
 
   /* Create resampler. Output params are unchanged
    * because we do not need conversion on the output. */
-  stm->resampler.reset(cubeb_resampler_create(stm,
-                                              has_input(stm) ? &input_unconverted_params : NULL,
-                                              has_output(stm) ? &stm->output_stream_params : NULL,
-                                              target_sample_rate,
-                                              stm->data_callback,
-                                              stm->user_ptr,
-                                              CUBEB_RESAMPLER_QUALITY_DESKTOP));
+  stm->resampler.reset(cubeb_resampler_create(
+      stm, has_input(stm) ? &input_unconverted_params : NULL,
+      has_output(stm) ? &stm->output_stream_params : NULL, target_sample_rate,
+      stm->data_callback, stm->user_ptr, CUBEB_RESAMPLER_QUALITY_DESKTOP));
   if (!stm->resampler) {
     LOG("(%p) Could not create resampler.", stm);
     return CUBEB_ERROR;
@@ -2710,20 +2721,25 @@ audiounit_setup_stream(cubeb_stream * stm)
       return CUBEB_ERROR;
     }
 
-    stm->current_latency_frames = audiounit_get_device_presentation_latency(stm->output_device.id, kAudioDevicePropertyScopeOutput);
+    stm->current_latency_frames = audiounit_get_device_presentation_latency(
+        stm->output_device.id, kAudioDevicePropertyScopeOutput);
 
     Float64 unit_s;
     UInt32 size = sizeof(unit_s);
-    if (AudioUnitGetProperty(stm->output_unit, kAudioUnitProperty_Latency, kAudioUnitScope_Global, 0, &unit_s, &size) == noErr) {
-      stm->current_latency_frames += static_cast<uint32_t>(unit_s * stm->output_desc.mSampleRate);
+    if (AudioUnitGetProperty(stm->output_unit, kAudioUnitProperty_Latency,
+                             kAudioUnitScope_Global, 0, &unit_s,
+                             &size) == noErr) {
+      stm->current_latency_frames +=
+          static_cast<uint32_t>(unit_s * stm->output_desc.mSampleRate);
     }
   }
 
   if (stm->input_unit && stm->output_unit) {
-    // According to the I/O hardware rate it is expected a specific pattern of callbacks
-    // for example is input is 44100 and output is 48000 we expected no more than 2
-    // out callback in a row.
-    stm->expected_output_callbacks_in_a_row = ceilf(stm->output_hw_rate / stm->input_hw_rate);
+    // According to the I/O hardware rate it is expected a specific pattern of
+    // callbacks for example is input is 44100 and output is 48000 we expected
+    // no more than 2 out callback in a row.
+    stm->expected_output_callbacks_in_a_row =
+        ceilf(stm->output_hw_rate / stm->input_hw_rate);
   }
 
   r = audiounit_install_device_changed_callback(stm);
@@ -2731,39 +2747,35 @@ audiounit_setup_stream(cubeb_stream * stm)
     LOG("(%p) Could not install all device change callback.", stm);
   }
 
-
   return CUBEB_OK;
 }
 
 cubeb_stream::cubeb_stream(cubeb * context)
-  : context(context)
-  , resampler(nullptr, cubeb_resampler_destroy)
-  , mixer(nullptr, cubeb_mixer_destroy)
+    : context(context), resampler(nullptr, cubeb_resampler_destroy),
+      mixer(nullptr, cubeb_mixer_destroy)
 {
   PodZero(&input_desc, 1);
   PodZero(&output_desc, 1);
 }
 
-static void audiounit_stream_destroy_internal(cubeb_stream * stm);
+static void
+audiounit_stream_destroy_internal(cubeb_stream * stm);
 
 static int
-audiounit_stream_init(cubeb * context,
-                      cubeb_stream ** stream,
-                      char const * /* stream_name */,
-                      cubeb_devid input_device,
+audiounit_stream_init(cubeb * context, cubeb_stream ** stream,
+                      char const * /* stream_name */, cubeb_devid input_device,
                       cubeb_stream_params * input_stream_params,
                       cubeb_devid output_device,
                       cubeb_stream_params * output_stream_params,
                       unsigned int latency_frames,
                       cubeb_data_callback data_callback,
-                      cubeb_state_callback state_callback,
-                      void * user_ptr)
+                      cubeb_state_callback state_callback, void * user_ptr)
 {
   assert(context);
   auto_lock context_lock(context->mutex);
   audiounit_increment_active_streams(context);
-  unique_ptr<cubeb_stream, decltype(&audiounit_stream_destroy)> stm(new cubeb_stream(context),
-                                                                    audiounit_stream_destroy_internal);
+  unique_ptr<cubeb_stream, decltype(&audiounit_stream_destroy)> stm(
+      new cubeb_stream(context), audiounit_stream_destroy_internal);
   int r;
   *stream = NULL;
   assert(latency_frames > 0);
@@ -2781,7 +2793,8 @@ audiounit_stream_init(cubeb * context,
   }
   if (input_stream_params) {
     stm->input_stream_params = *input_stream_params;
-    r = audiounit_set_device_info(stm.get(), reinterpret_cast<uintptr_t>(input_device), io_side::INPUT);
+    r = audiounit_set_device_info(
+        stm.get(), reinterpret_cast<uintptr_t>(input_device), io_side::INPUT);
     if (r != CUBEB_OK) {
       LOG("(%p) Fail to set device info for input.", stm.get());
       return r;
@@ -2789,7 +2802,8 @@ audiounit_stream_init(cubeb * context,
   }
   if (output_stream_params) {
     stm->output_stream_params = *output_stream_params;
-    r = audiounit_set_device_info(stm.get(), reinterpret_cast<uintptr_t>(output_device), io_side::OUTPUT);
+    r = audiounit_set_device_info(
+        stm.get(), reinterpret_cast<uintptr_t>(output_device), io_side::OUTPUT);
     if (r != CUBEB_OK) {
       LOG("(%p) Fail to set device info for output.", stm.get());
       return r;
@@ -2821,7 +2835,7 @@ audiounit_stream_init(cubeb * context,
 }
 
 static void
-audiounit_close_stream(cubeb_stream *stm)
+audiounit_close_stream(cubeb_stream * stm)
 {
   stm->mutex.assert_current_thread_owns();
 
@@ -2843,13 +2857,14 @@ audiounit_close_stream(cubeb_stream *stm)
   stm->mixer.reset();
 
   if (stm->aggregate_device_id != kAudioObjectUnknown) {
-    audiounit_destroy_aggregate_device(stm->plugin_id, &stm->aggregate_device_id);
+    audiounit_destroy_aggregate_device(stm->plugin_id,
+                                       &stm->aggregate_device_id);
     stm->aggregate_device_id = kAudioObjectUnknown;
   }
 }
 
 static void
-audiounit_stream_destroy_internal(cubeb_stream *stm)
+audiounit_stream_destroy_internal(cubeb_stream * stm)
 {
   stm->context->mutex.assert_current_thread_owns();
 
@@ -2880,7 +2895,7 @@ audiounit_stream_destroy(cubeb_stream * stm)
     LOG("(%p) Could not uninstall all device change listeners", stm);
   }
 
-  if (!stm->shutdown.load()){
+  if (!stm->shutdown.load()) {
     auto_lock context_lock(stm->context->mutex);
     audiounit_stream_stop_internal(stm);
     stm->shutdown = true;
@@ -2981,7 +2996,7 @@ int
 audiounit_stream_get_latency(cubeb_stream * stm, uint32_t * latency)
 {
 #if TARGET_OS_IPHONE
-  //TODO
+  // TODO
   return CUBEB_ERROR_NOT_SUPPORTED;
 #else
   *latency = stm->total_output_latency_frames;
@@ -2993,10 +3008,8 @@ static int
 audiounit_stream_get_volume(cubeb_stream * stm, float * volume)
 {
   assert(stm->output_unit);
-  OSStatus r = AudioUnitGetParameter(stm->output_unit,
-                                     kHALOutputParam_Volume,
-                                     kAudioUnitScope_Global,
-                                     0, volume);
+  OSStatus r = AudioUnitGetParameter(stm->output_unit, kHALOutputParam_Volume,
+                                     kAudioUnitScope_Global, 0, volume);
   if (r != noErr) {
     LOG("AudioUnitGetParameter/kHALOutputParam_Volume rv=%d", r);
     return CUBEB_ERROR;
@@ -3009,10 +3022,8 @@ audiounit_stream_set_volume(cubeb_stream * stm, float volume)
 {
   assert(stm->output_unit);
   OSStatus r;
-  r = AudioUnitSetParameter(stm->output_unit,
-                            kHALOutputParam_Volume,
-                            kAudioUnitScope_Global,
-                            0, volume, 0);
+  r = AudioUnitSetParameter(stm->output_unit, kHALOutputParam_Volume,
+                            kAudioUnitScope_Global, 0, volume, 0);
 
   if (r != noErr) {
     LOG("AudioUnitSetParameter/kHALOutputParam_Volume rv=%d", r);
@@ -3021,11 +3032,12 @@ audiounit_stream_set_volume(cubeb_stream * stm, float volume)
   return CUBEB_OK;
 }
 
-unique_ptr<char[]> convert_uint32_into_string(UInt32 data)
+unique_ptr<char[]>
+convert_uint32_into_string(UInt32 data)
 {
   // Simply create an empty string if no data.
-  size_t size = data == 0 ? 0 : 4; // 4 bytes for uint32.
-  auto str = unique_ptr<char[]> { new char[size + 1] }; // + 1 for '\0'.
+  size_t size = data == 0 ? 0 : 4;                   // 4 bytes for uint32.
+  auto str = unique_ptr<char[]>{new char[size + 1]}; // + 1 for '\0'.
   str[size] = '\0';
   if (size < 4) {
     return str;
@@ -3039,8 +3051,8 @@ unique_ptr<char[]> convert_uint32_into_string(UInt32 data)
   return str;
 }
 
-int audiounit_get_default_device_datasource(cubeb_device_type type,
-                                            UInt32 * data)
+int
+audiounit_get_default_device_datasource(cubeb_device_type type, UInt32 * data)
 {
   AudioDeviceID id = audiounit_get_default_device_id(type);
   if (id == kAudioObjectUnknown) {
@@ -3049,11 +3061,11 @@ int audiounit_get_default_device_datasource(cubeb_device_type type,
 
   UInt32 size = sizeof(*data);
   /* This fails with some USB headsets (e.g., Plantronic .Audio 628). */
-  OSStatus r = AudioObjectGetPropertyData(id,
-                                          type == CUBEB_DEVICE_TYPE_INPUT ?
-                                            &INPUT_DATA_SOURCE_PROPERTY_ADDRESS :
-                                            &OUTPUT_DATA_SOURCE_PROPERTY_ADDRESS,
-                                          0, NULL, &size, data);
+  OSStatus r = AudioObjectGetPropertyData(
+      id,
+      type == CUBEB_DEVICE_TYPE_INPUT ? &INPUT_DATA_SOURCE_PROPERTY_ADDRESS
+                                      : &OUTPUT_DATA_SOURCE_PROPERTY_ADDRESS,
+      0, NULL, &size, data);
   if (r != noErr) {
     *data = 0;
   }
@@ -3061,9 +3073,10 @@ int audiounit_get_default_device_datasource(cubeb_device_type type,
   return CUBEB_OK;
 }
 
-int audiounit_get_default_device_name(cubeb_stream * stm,
-                                      cubeb_device * const device,
-                                      cubeb_device_type type)
+int
+audiounit_get_default_device_name(cubeb_stream * stm,
+                                  cubeb_device * const device,
+                                  cubeb_device_type type)
 {
   assert(stm);
   assert(device);
@@ -3073,8 +3086,8 @@ int audiounit_get_default_device_name(cubeb_stream * stm,
   if (r != CUBEB_OK) {
     return r;
   }
-  char ** name = type == CUBEB_DEVICE_TYPE_INPUT ?
-    &device->input_name : &device->output_name;
+  char ** name = type == CUBEB_DEVICE_TYPE_INPUT ? &device->input_name
+                                                 : &device->output_name;
   *name = convert_uint32_into_string(data).release();
   if (!strlen(*name)) { // empty string.
     LOG("(%p) name of %s device is empty!", stm,
@@ -3083,12 +3096,12 @@ int audiounit_get_default_device_name(cubeb_stream * stm,
   return CUBEB_OK;
 }
 
-
-int audiounit_stream_get_current_device(cubeb_stream * stm,
-                                        cubeb_device ** const device)
+int
+audiounit_stream_get_current_device(cubeb_stream * stm,
+                                    cubeb_device ** const device)
 {
 #if TARGET_OS_IPHONE
-  //TODO
+  // TODO
   return CUBEB_ERROR_NOT_SUPPORTED;
 #else
   *device = new cubeb_device;
@@ -3097,14 +3110,13 @@ int audiounit_stream_get_current_device(cubeb_stream * stm,
   }
   PodZero(*device, 1);
 
-  int r = audiounit_get_default_device_name(stm, *device,
-                                            CUBEB_DEVICE_TYPE_OUTPUT);
+  int r =
+      audiounit_get_default_device_name(stm, *device, CUBEB_DEVICE_TYPE_OUTPUT);
   if (r != CUBEB_OK) {
     return r;
   }
 
-  r = audiounit_get_default_device_name(stm, *device,
-                                        CUBEB_DEVICE_TYPE_INPUT);
+  r = audiounit_get_default_device_name(stm, *device, CUBEB_DEVICE_TYPE_INPUT);
   if (r != CUBEB_OK) {
     return r;
   }
@@ -3113,17 +3125,20 @@ int audiounit_stream_get_current_device(cubeb_stream * stm,
 #endif
 }
 
-int audiounit_stream_device_destroy(cubeb_stream * /* stream */,
-                                    cubeb_device * device)
+int
+audiounit_stream_device_destroy(cubeb_stream * /* stream */,
+                                cubeb_device * device)
 {
-  delete [] device->output_name;
-  delete [] device->input_name;
+  delete[] device->output_name;
+  delete[] device->input_name;
   delete device;
   return CUBEB_OK;
 }
 
-int audiounit_stream_register_device_changed_callback(cubeb_stream * stream,
-                                                      cubeb_device_changed_callback device_changed_callback)
+int
+audiounit_stream_register_device_changed_callback(
+    cubeb_stream * stream,
+    cubeb_device_changed_callback device_changed_callback)
 {
   auto_lock dev_cb_lock(stream->device_changed_callback_lock);
   /* Note: second register without unregister first causes 'nope' error.
@@ -3148,7 +3163,7 @@ audiounit_strref_to_cstr_utf8(CFStringRef strref)
   ret = new char[size];
 
   if (!CFStringGetCString(strref, ret, size, kCFStringEncodingUTF8)) {
-    delete [] ret;
+    delete[] ret;
     ret = NULL;
   }
 
@@ -3158,15 +3173,18 @@ audiounit_strref_to_cstr_utf8(CFStringRef strref)
 static uint32_t
 audiounit_get_channel_count(AudioObjectID devid, AudioObjectPropertyScope scope)
 {
-  AudioObjectPropertyAddress adr = { 0, scope, kAudioObjectPropertyElementMaster };
+  AudioObjectPropertyAddress adr = {0, scope,
+                                    kAudioObjectPropertyElementMaster};
   UInt32 size = 0;
   uint32_t i, ret = 0;
 
   adr.mSelector = kAudioDevicePropertyStreamConfiguration;
 
-  if (AudioObjectGetPropertyDataSize(devid, &adr, 0, NULL, &size) == noErr && size > 0) {
+  if (AudioObjectGetPropertyDataSize(devid, &adr, 0, NULL, &size) == noErr &&
+      size > 0) {
     AudioBufferList * list = static_cast<AudioBufferList *>(alloca(size));
-    if (AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, list) == noErr) {
+    if (AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, list) ==
+        noErr) {
       for (i = 0; i < list->mNumberBuffers; i++)
         ret += list->mBuffers[i].mNumberChannels;
     }
@@ -3176,16 +3194,20 @@ audiounit_get_channel_count(AudioObjectID devid, AudioObjectPropertyScope scope)
 }
 
 static void
-audiounit_get_available_samplerate(AudioObjectID devid, AudioObjectPropertyScope scope,
-                                   uint32_t * min, uint32_t * max, uint32_t * def)
+audiounit_get_available_samplerate(AudioObjectID devid,
+                                   AudioObjectPropertyScope scope,
+                                   uint32_t * min, uint32_t * max,
+                                   uint32_t * def)
 {
-  AudioObjectPropertyAddress adr = { 0, scope, kAudioObjectPropertyElementMaster };
+  AudioObjectPropertyAddress adr = {0, scope,
+                                    kAudioObjectPropertyElementMaster};
 
   adr.mSelector = kAudioDevicePropertyNominalSampleRate;
   if (AudioObjectHasProperty(devid, &adr)) {
     UInt32 size = sizeof(Float64);
     Float64 fvalue = 0.0;
-    if (AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, &fvalue) == noErr) {
+    if (AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, &fvalue) ==
+        noErr) {
       *def = fvalue;
     }
   }
@@ -3199,7 +3221,8 @@ audiounit_get_available_samplerate(AudioObjectID devid, AudioObjectPropertyScope
     vector<AudioValueRange> ranges(count);
     range.mMinimum = 9999999999.0;
     range.mMaximum = 0.0;
-    if (AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, ranges.data()) == noErr) {
+    if (AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size,
+                                   ranges.data()) == noErr) {
       for (uint32_t i = 0; i < count; i++) {
         if (ranges[i].mMaximum > range.mMaximum)
           range.mMaximum = ranges[i].mMaximum;
@@ -3212,13 +3235,14 @@ audiounit_get_available_samplerate(AudioObjectID devid, AudioObjectPropertyScope
   } else {
     *min = *max = 0;
   }
-
 }
 
 static UInt32
-audiounit_get_device_presentation_latency(AudioObjectID devid, AudioObjectPropertyScope scope)
+audiounit_get_device_presentation_latency(AudioObjectID devid,
+                                          AudioObjectPropertyScope scope)
 {
-  AudioObjectPropertyAddress adr = { 0, scope, kAudioObjectPropertyElementMaster };
+  AudioObjectPropertyAddress adr = {0, scope,
+                                    kAudioObjectPropertyElementMaster};
   UInt32 size, dev, stream = 0;
   AudioStreamID sid[1];
 
@@ -3240,9 +3264,10 @@ audiounit_get_device_presentation_latency(AudioObjectID devid, AudioObjectProper
 }
 
 static int
-audiounit_create_device_from_hwdev(cubeb_device_info * dev_info, AudioObjectID devid, cubeb_device_type type)
+audiounit_create_device_from_hwdev(cubeb_device_info * dev_info,
+                                   AudioObjectID devid, cubeb_device_type type)
 {
-  AudioObjectPropertyAddress adr = { 0, 0, kAudioObjectPropertyElementMaster };
+  AudioObjectPropertyAddress adr = {0, 0, kAudioObjectPropertyElementMaster};
   UInt32 size;
 
   if (type == CUBEB_DEVICE_TYPE_OUTPUT) {
@@ -3263,10 +3288,12 @@ audiounit_create_device_from_hwdev(cubeb_device_info * dev_info, AudioObjectID d
   CFStringRef device_id_str = nullptr;
   size = sizeof(CFStringRef);
   adr.mSelector = kAudioDevicePropertyDeviceUID;
-  OSStatus ret = AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, &device_id_str);
-  if ( ret == noErr && device_id_str != NULL) {
+  OSStatus ret =
+      AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, &device_id_str);
+  if (ret == noErr && device_id_str != NULL) {
     dev_info->device_id = audiounit_strref_to_cstr_utf8(device_id_str);
-    static_assert(sizeof(cubeb_devid) >= sizeof(decltype(devid)), "cubeb_devid can't represent devid");
+    static_assert(sizeof(cubeb_devid) >= sizeof(decltype(devid)),
+                  "cubeb_devid can't represent devid");
     dev_info->devid = reinterpret_cast<cubeb_devid>(devid);
     dev_info->group_id = dev_info->device_id;
     CFRelease(device_id_str);
@@ -3278,7 +3305,8 @@ audiounit_create_device_from_hwdev(cubeb_device_info * dev_info, AudioObjectID d
   adr.mSelector = kAudioDevicePropertyDataSource;
   ret = AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, &ds);
   if (ret == noErr) {
-    AudioValueTranslation trl = { &ds, sizeof(ds), &friendly_name_str, sizeof(CFStringRef) };
+    AudioValueTranslation trl = {&ds, sizeof(ds), &friendly_name_str,
+                                 sizeof(CFStringRef)};
     adr.mSelector = kAudioDevicePropertyDataSourceNameForIDCFString;
     size = sizeof(AudioValueTranslation);
     AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, &trl);
@@ -3306,7 +3334,8 @@ audiounit_create_device_from_hwdev(cubeb_device_info * dev_info, AudioObjectID d
   CFStringRef vendor_name_str = nullptr;
   size = sizeof(CFStringRef);
   adr.mSelector = kAudioObjectPropertyManufacturer;
-  ret = AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, &vendor_name_str);
+  ret =
+      AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, &vendor_name_str);
   if (ret == noErr && vendor_name_str != NULL) {
     dev_info->vendor_name = audiounit_strref_to_cstr_utf8(vendor_name_str);
     CFRelease(vendor_name_str);
@@ -3314,15 +3343,18 @@ audiounit_create_device_from_hwdev(cubeb_device_info * dev_info, AudioObjectID d
 
   dev_info->type = type;
   dev_info->state = CUBEB_DEVICE_STATE_ENABLED;
-  dev_info->preferred = (devid == audiounit_get_default_device_id(type)) ?
-    CUBEB_DEVICE_PREF_ALL : CUBEB_DEVICE_PREF_NONE;
+  dev_info->preferred = (devid == audiounit_get_default_device_id(type))
+                            ? CUBEB_DEVICE_PREF_ALL
+                            : CUBEB_DEVICE_PREF_NONE;
 
   dev_info->max_channels = ch;
-  dev_info->format = (cubeb_device_fmt)CUBEB_DEVICE_FMT_ALL; /* CoreAudio supports All! */
+  dev_info->format =
+      (cubeb_device_fmt)CUBEB_DEVICE_FMT_ALL; /* CoreAudio supports All! */
   /* kAudioFormatFlagsAudioUnitCanonical is deprecated, prefer floating point */
   dev_info->default_format = CUBEB_DEVICE_FMT_F32NE;
-  audiounit_get_available_samplerate(devid, adr.mScope,
-                                     &dev_info->min_rate, &dev_info->max_rate, &dev_info->default_rate);
+  audiounit_get_available_samplerate(devid, adr.mScope, &dev_info->min_rate,
+                                     &dev_info->max_rate,
+                                     &dev_info->default_rate);
 
   UInt32 latency = audiounit_get_device_presentation_latency(devid, adr.mScope);
 
@@ -3334,8 +3366,10 @@ audiounit_create_device_from_hwdev(cubeb_device_info * dev_info, AudioObjectID d
     dev_info->latency_lo = latency + range.mMinimum;
     dev_info->latency_hi = latency + range.mMaximum;
   } else {
-    dev_info->latency_lo = 10 * dev_info->default_rate / 1000;  /* Default to 10ms */
-    dev_info->latency_hi = 100 * dev_info->default_rate / 1000; /* Default to 100ms */
+    dev_info->latency_lo =
+        10 * dev_info->default_rate / 1000; /* Default to 10ms */
+    dev_info->latency_hi =
+        100 * dev_info->default_rate / 1000; /* Default to 100ms */
   }
 
   return CUBEB_OK;
@@ -3374,9 +3408,10 @@ audiounit_enumerate_devices(cubeb * /* context */, cubeb_device_type type,
   collection->count = 0;
 
   if (type & CUBEB_DEVICE_TYPE_OUTPUT) {
-    for (auto dev: output_devs) {
+    for (auto dev : output_devs) {
       auto device = &devices[collection->count];
-      auto err = audiounit_create_device_from_hwdev(device, dev, CUBEB_DEVICE_TYPE_OUTPUT);
+      auto err = audiounit_create_device_from_hwdev(device, dev,
+                                                    CUBEB_DEVICE_TYPE_OUTPUT);
       if (err != CUBEB_OK || is_aggregate_device(device)) {
         continue;
       }
@@ -3385,9 +3420,10 @@ audiounit_enumerate_devices(cubeb * /* context */, cubeb_device_type type,
   }
 
   if (type & CUBEB_DEVICE_TYPE_INPUT) {
-    for (auto dev: input_devs) {
+    for (auto dev : input_devs) {
       auto device = &devices[collection->count];
-      auto err = audiounit_create_device_from_hwdev(device, dev, CUBEB_DEVICE_TYPE_INPUT);
+      auto err = audiounit_create_device_from_hwdev(device, dev,
+                                                    CUBEB_DEVICE_TYPE_INPUT);
       if (err != CUBEB_OK || is_aggregate_device(device)) {
         continue;
       }
@@ -3398,7 +3434,7 @@ audiounit_enumerate_devices(cubeb * /* context */, cubeb_device_type type,
   if (collection->count > 0) {
     collection->device = devices;
   } else {
-    delete [] devices;
+    delete[] devices;
     collection->device = NULL;
   }
 
@@ -3408,9 +3444,9 @@ audiounit_enumerate_devices(cubeb * /* context */, cubeb_device_type type,
 static void
 audiounit_device_destroy(cubeb_device_info * device)
 {
-  delete [] device->device_id;
-  delete [] device->friendly_name;
-  delete [] device->vendor_name;
+  delete[] device->device_id;
+  delete[] device->friendly_name;
+  delete[] device->vendor_name;
 }
 
 static int
@@ -3420,7 +3456,7 @@ audiounit_device_collection_destroy(cubeb * /* context */,
   for (size_t i = 0; i < collection->count; i++) {
     audiounit_device_destroy(&collection->device[i]);
   }
-  delete [] collection->device;
+  delete[] collection->device;
 
   return CUBEB_OK;
 }
@@ -3429,9 +3465,8 @@ static vector<AudioObjectID>
 audiounit_get_devices_of_type(cubeb_device_type devtype)
 {
   UInt32 size = 0;
-  OSStatus ret = AudioObjectGetPropertyDataSize(kAudioObjectSystemObject,
-                                                &DEVICES_PROPERTY_ADDRESS, 0,
-                                                NULL, &size);
+  OSStatus ret = AudioObjectGetPropertyDataSize(
+      kAudioObjectSystemObject, &DEVICES_PROPERTY_ADDRESS, 0, NULL, &size);
   if (ret != noErr) {
     return vector<AudioObjectID>();
   }
@@ -3447,7 +3482,7 @@ audiounit_get_devices_of_type(cubeb_device_type devtype)
   for (auto it = devices.begin(); it != devices.end();) {
     CFStringRef name = get_device_name(*it);
     if (name && CFStringFind(name, CFSTR("CubebAggregateDevice"), 0).location !=
-        kCFNotFound) {
+                    kCFNotFound) {
       it = devices.erase(it);
     } else {
       it++;
@@ -3458,17 +3493,16 @@ audiounit_get_devices_of_type(cubeb_device_type devtype)
   }
 
   /* Expected sorted but did not find anything in the docs. */
-  sort(devices.begin(), devices.end(), [](AudioObjectID a, AudioObjectID b) {
-      return a < b;
-    });
+  sort(devices.begin(), devices.end(),
+       [](AudioObjectID a, AudioObjectID b) { return a < b; });
 
   if (devtype == (CUBEB_DEVICE_TYPE_INPUT | CUBEB_DEVICE_TYPE_OUTPUT)) {
     return devices;
   }
 
-  AudioObjectPropertyScope scope = (devtype == CUBEB_DEVICE_TYPE_INPUT) ?
-                                         kAudioDevicePropertyScopeInput :
-                                         kAudioDevicePropertyScopeOutput;
+  AudioObjectPropertyScope scope = (devtype == CUBEB_DEVICE_TYPE_INPUT)
+                                       ? kAudioDevicePropertyScopeInput
+                                       : kAudioDevicePropertyScopeOutput;
 
   vector<AudioObjectID> devices_in_scope;
   for (uint32_t i = 0; i < devices.size(); ++i) {
@@ -3482,35 +3516,39 @@ audiounit_get_devices_of_type(cubeb_device_type devtype)
 }
 
 static OSStatus
-audiounit_collection_changed_callback(AudioObjectID /* inObjectID */,
-                                      UInt32 /* inNumberAddresses */,
-                                      const AudioObjectPropertyAddress * /* inAddresses */,
-                                      void * inClientData)
+audiounit_collection_changed_callback(
+    AudioObjectID /* inObjectID */, UInt32 /* inNumberAddresses */,
+    const AudioObjectPropertyAddress * /* inAddresses */, void * inClientData)
 {
   cubeb * context = static_cast<cubeb *>(inClientData);
 
-  // This can be called from inside an AudioUnit function, dispatch to another queue.
+  // This can be called from inside an AudioUnit function, dispatch to another
+  // queue.
   dispatch_async(context->serial_queue, ^() {
     auto_lock lock(context->mutex);
     if (!context->input_collection_changed_callback &&
-      !context->output_collection_changed_callback) {
+        !context->output_collection_changed_callback) {
       /* Listener removed while waiting in mutex, abort. */
       return;
     }
     if (context->input_collection_changed_callback) {
-      vector<AudioObjectID> devices = audiounit_get_devices_of_type(CUBEB_DEVICE_TYPE_INPUT);
+      vector<AudioObjectID> devices =
+          audiounit_get_devices_of_type(CUBEB_DEVICE_TYPE_INPUT);
       /* Elements in the vector expected sorted. */
       if (context->input_device_array != devices) {
         context->input_device_array = devices;
-        context->input_collection_changed_callback(context, context->input_collection_changed_user_ptr);
+        context->input_collection_changed_callback(
+            context, context->input_collection_changed_user_ptr);
       }
     }
     if (context->output_collection_changed_callback) {
-      vector<AudioObjectID> devices = audiounit_get_devices_of_type(CUBEB_DEVICE_TYPE_OUTPUT);
+      vector<AudioObjectID> devices =
+          audiounit_get_devices_of_type(CUBEB_DEVICE_TYPE_OUTPUT);
       /* Elements in the vector expected sorted. */
       if (context->output_device_array != devices) {
         context->output_device_array = devices;
-        context->output_collection_changed_callback(context, context->output_collection_changed_user_ptr);
+        context->output_collection_changed_callback(
+            context, context->output_collection_changed_user_ptr);
       }
     }
   });
@@ -3518,24 +3556,25 @@ audiounit_collection_changed_callback(AudioObjectID /* inObjectID */,
 }
 
 static OSStatus
-audiounit_add_device_listener(cubeb * context,
-                              cubeb_device_type devtype,
-                              cubeb_device_collection_changed_callback collection_changed_callback,
-                              void * user_ptr)
+audiounit_add_device_listener(
+    cubeb * context, cubeb_device_type devtype,
+    cubeb_device_collection_changed_callback collection_changed_callback,
+    void * user_ptr)
 {
   context->mutex.assert_current_thread_owns();
   assert(devtype & (CUBEB_DEVICE_TYPE_INPUT | CUBEB_DEVICE_TYPE_OUTPUT));
   /* Note: second register without unregister first causes 'nope' error.
    * Current implementation requires unregister before register a new cb. */
-  assert((devtype & CUBEB_DEVICE_TYPE_INPUT) && !context->input_collection_changed_callback ||
-         (devtype & CUBEB_DEVICE_TYPE_OUTPUT) && !context->output_collection_changed_callback);
+  assert((devtype & CUBEB_DEVICE_TYPE_INPUT) &&
+             !context->input_collection_changed_callback ||
+         (devtype & CUBEB_DEVICE_TYPE_OUTPUT) &&
+             !context->output_collection_changed_callback);
 
   if (!context->input_collection_changed_callback &&
       !context->output_collection_changed_callback) {
-    OSStatus ret = AudioObjectAddPropertyListener(kAudioObjectSystemObject,
-                                                  &DEVICES_PROPERTY_ADDRESS,
-                                                  audiounit_collection_changed_callback,
-                                                  context);
+    OSStatus ret = AudioObjectAddPropertyListener(
+        kAudioObjectSystemObject, &DEVICES_PROPERTY_ADDRESS,
+        audiounit_collection_changed_callback, context);
     if (ret != noErr) {
       return ret;
     }
@@ -3543,14 +3582,16 @@ audiounit_add_device_listener(cubeb * context,
   if (devtype & CUBEB_DEVICE_TYPE_INPUT) {
     /* Expected empty after unregister. */
     assert(context->input_device_array.empty());
-    context->input_device_array = audiounit_get_devices_of_type(CUBEB_DEVICE_TYPE_INPUT);
+    context->input_device_array =
+        audiounit_get_devices_of_type(CUBEB_DEVICE_TYPE_INPUT);
     context->input_collection_changed_callback = collection_changed_callback;
     context->input_collection_changed_user_ptr = user_ptr;
   }
   if (devtype & CUBEB_DEVICE_TYPE_OUTPUT) {
     /* Expected empty after unregister. */
     assert(context->output_device_array.empty());
-    context->output_device_array = audiounit_get_devices_of_type(CUBEB_DEVICE_TYPE_OUTPUT);
+    context->output_device_array =
+        audiounit_get_devices_of_type(CUBEB_DEVICE_TYPE_OUTPUT);
     context->output_collection_changed_callback = collection_changed_callback;
     context->output_collection_changed_user_ptr = user_ptr;
   }
@@ -3578,16 +3619,16 @@ audiounit_remove_device_listener(cubeb * context, cubeb_device_type devtype)
     return noErr;
   }
   /* Note: unregister a non registered cb is not a problem, not checking. */
-  return AudioObjectRemovePropertyListener(kAudioObjectSystemObject,
-                                           &DEVICES_PROPERTY_ADDRESS,
-                                           audiounit_collection_changed_callback,
-                                           context);
+  return AudioObjectRemovePropertyListener(
+      kAudioObjectSystemObject, &DEVICES_PROPERTY_ADDRESS,
+      audiounit_collection_changed_callback, context);
 }
 
-int audiounit_register_device_collection_changed(cubeb * context,
-                                                 cubeb_device_type devtype,
-                                                 cubeb_device_collection_changed_callback collection_changed_callback,
-                                                 void * user_ptr)
+int
+audiounit_register_device_collection_changed(
+    cubeb * context, cubeb_device_type devtype,
+    cubeb_device_collection_changed_callback collection_changed_callback,
+    void * user_ptr)
 {
   if (devtype == CUBEB_DEVICE_TYPE_UNKNOWN) {
     return CUBEB_ERROR_INVALID_PARAMETER;
@@ -3595,10 +3636,8 @@ int audiounit_register_device_collection_changed(cubeb * context,
   OSStatus ret;
   auto_lock lock(context->mutex);
   if (collection_changed_callback) {
-    ret = audiounit_add_device_listener(context,
-                                        devtype,
-                                        collection_changed_callback,
-                                        user_ptr);
+    ret = audiounit_add_device_listener(context, devtype,
+                                        collection_changed_callback, user_ptr);
   } else {
     ret = audiounit_remove_device_listener(context, devtype);
   }
@@ -3606,25 +3645,26 @@ int audiounit_register_device_collection_changed(cubeb * context,
 }
 
 cubeb_ops const audiounit_ops = {
-  /*.init =*/ audiounit_init,
-  /*.get_backend_id =*/ audiounit_get_backend_id,
-  /*.get_max_channel_count =*/ audiounit_get_max_channel_count,
-  /*.get_min_latency =*/ audiounit_get_min_latency,
-  /*.get_preferred_sample_rate =*/ audiounit_get_preferred_sample_rate,
-  /*.enumerate_devices =*/ audiounit_enumerate_devices,
-  /*.device_collection_destroy =*/ audiounit_device_collection_destroy,
-  /*.destroy =*/ audiounit_destroy,
-  /*.stream_init =*/ audiounit_stream_init,
-  /*.stream_destroy =*/ audiounit_stream_destroy,
-  /*.stream_start =*/ audiounit_stream_start,
-  /*.stream_stop =*/ audiounit_stream_stop,
-  /*.stream_get_position =*/ audiounit_stream_get_position,
-  /*.stream_get_latency =*/ audiounit_stream_get_latency,
-  /*.stream_get_input_latency =*/ NULL,
-  /*.stream_set_volume =*/ audiounit_stream_set_volume,
-  /*.stream_set_name =*/ NULL,
-  /*.stream_get_current_device =*/ audiounit_stream_get_current_device,
-  /*.stream_device_destroy =*/ audiounit_stream_device_destroy,
-  /*.stream_register_device_changed_callback =*/ audiounit_stream_register_device_changed_callback,
-  /*.register_device_collection_changed =*/ audiounit_register_device_collection_changed
-};
+    /*.init =*/audiounit_init,
+    /*.get_backend_id =*/audiounit_get_backend_id,
+    /*.get_max_channel_count =*/audiounit_get_max_channel_count,
+    /*.get_min_latency =*/audiounit_get_min_latency,
+    /*.get_preferred_sample_rate =*/audiounit_get_preferred_sample_rate,
+    /*.enumerate_devices =*/audiounit_enumerate_devices,
+    /*.device_collection_destroy =*/audiounit_device_collection_destroy,
+    /*.destroy =*/audiounit_destroy,
+    /*.stream_init =*/audiounit_stream_init,
+    /*.stream_destroy =*/audiounit_stream_destroy,
+    /*.stream_start =*/audiounit_stream_start,
+    /*.stream_stop =*/audiounit_stream_stop,
+    /*.stream_get_position =*/audiounit_stream_get_position,
+    /*.stream_get_latency =*/audiounit_stream_get_latency,
+    /*.stream_get_input_latency =*/NULL,
+    /*.stream_set_volume =*/audiounit_stream_set_volume,
+    /*.stream_set_name =*/NULL,
+    /*.stream_get_current_device =*/audiounit_stream_get_current_device,
+    /*.stream_device_destroy =*/audiounit_stream_device_destroy,
+    /*.stream_register_device_changed_callback =*/
+    audiounit_stream_register_device_changed_callback,
+    /*.register_device_collection_changed =*/
+    audiounit_register_device_collection_changed};
diff --git a/src/cubeb_jack.cpp b/src/cubeb_jack.cpp
index 1a1305f..9dc5199 100644
--- a/src/cubeb_jack.cpp
+++ b/src/cubeb_jack.cpp
@@ -11,40 +11,40 @@
 #ifndef __FreeBSD__
 #define _POSIX_SOURCE
 #endif
-#include <dlfcn.h>
-#include <stdio.h>
-#include <string.h>
-#include <limits.h>
-#include <stdlib.h>
-#include <pthread.h>
-#include <math.h>
-#include "cubeb/cubeb.h"
 #include "cubeb-internal.h"
+#include "cubeb/cubeb.h"
 #include "cubeb_resampler.h"
 #include "cubeb_utils.h"
+#include <dlfcn.h>
+#include <limits.h>
+#include <math.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
 #include <jack/jack.h>
 #include <jack/statistics.h>
 
-#define JACK_API_VISIT(X)                       \
-  X(jack_activate)                              \
-  X(jack_client_close)                          \
-  X(jack_client_open)                           \
-  X(jack_connect)                               \
-  X(jack_free)                                  \
-  X(jack_get_ports)                             \
-  X(jack_get_sample_rate)                       \
-  X(jack_get_xrun_delayed_usecs)                \
-  X(jack_get_buffer_size)                       \
-  X(jack_port_get_buffer)                       \
-  X(jack_port_name)                             \
-  X(jack_port_register)                         \
-  X(jack_port_unregister)                       \
-  X(jack_port_get_latency_range)                \
-  X(jack_set_process_callback)                  \
-  X(jack_set_xrun_callback)                     \
-  X(jack_set_graph_order_callback)              \
-  X(jack_set_error_function)                    \
+#define JACK_API_VISIT(X)                                                      \
+  X(jack_activate)                                                             \
+  X(jack_client_close)                                                         \
+  X(jack_client_open)                                                          \
+  X(jack_connect)                                                              \
+  X(jack_free)                                                                 \
+  X(jack_get_ports)                                                            \
+  X(jack_get_sample_rate)                                                      \
+  X(jack_get_xrun_delayed_usecs)                                               \
+  X(jack_get_buffer_size)                                                      \
+  X(jack_port_get_buffer)                                                      \
+  X(jack_port_name)                                                            \
+  X(jack_port_register)                                                        \
+  X(jack_port_unregister)                                                      \
+  X(jack_port_get_latency_range)                                               \
+  X(jack_set_process_callback)                                                 \
+  X(jack_set_xrun_callback)                                                    \
+  X(jack_set_graph_order_callback)                                             \
+  X(jack_set_error_function)                                                   \
   X(jack_set_info_function)
 
 #define IMPORT_FUNC(x) static decltype(x) * api_##x;
@@ -54,7 +54,7 @@ JACK_API_VISIT(IMPORT_FUNC);
 #define JACK_DEFAULT_OUT "JACK playback"
 
 static const int MAX_STREAMS = 16;
-static const int MAX_CHANNELS  = 8;
+static const int MAX_CHANNELS = 8;
 static const int FIFO_SIZE = 4096 * sizeof(float);
 
 enum devstream {
@@ -81,70 +81,95 @@ static void
 float_to_s16ne(int16_t * dst, float * src, size_t n)
 {
   for (size_t i = 0; i < n; i++) {
-    if (*src > 1.f) *src = 1.f;
-    if (*src < -1.f) *src = -1.f;
+    if (*src > 1.f)
+      *src = 1.f;
+    if (*src < -1.f)
+      *src = -1.f;
     *(dst++) = (int16_t)((int16_t)(*(src++) * 32767));
   }
 }
 
-extern "C"
-{
-/*static*/ int jack_init (cubeb ** context, char const * context_name);
+extern "C" {
+/*static*/ int
+jack_init(cubeb ** context, char const * context_name);
 }
-static char const * cbjack_get_backend_id(cubeb * context);
-static int cbjack_get_max_channel_count(cubeb * ctx, uint32_t * max_channels);
-static int cbjack_get_min_latency(cubeb * ctx, cubeb_stream_params params, uint32_t * latency_frames);
-static int cbjack_get_latency(cubeb_stream * stm, unsigned int * latency_frames);
-static int cbjack_get_preferred_sample_rate(cubeb * ctx, uint32_t * rate);
-static void cbjack_destroy(cubeb * context);
-static void cbjack_interleave_capture(cubeb_stream * stream, float **in, jack_nframes_t nframes, bool format_mismatch);
-static void cbjack_deinterleave_playback_refill_s16ne(cubeb_stream * stream, short **bufs_in, float **bufs_out, jack_nframes_t nframes);
-static void cbjack_deinterleave_playback_refill_float(cubeb_stream * stream, float **bufs_in, float **bufs_out, jack_nframes_t nframes);
-static int cbjack_stream_device_destroy(cubeb_stream * stream,
-                                        cubeb_device * device);
-static int cbjack_stream_get_current_device(cubeb_stream * stm, cubeb_device ** const device);
-static int cbjack_enumerate_devices(cubeb * context, cubeb_device_type type,
-                                    cubeb_device_collection * collection);
-static int cbjack_device_collection_destroy(cubeb * context,
-                                            cubeb_device_collection * collection);
-static int cbjack_stream_init(cubeb * context, cubeb_stream ** stream, char const * stream_name,
-                              cubeb_devid input_device,
-                              cubeb_stream_params * input_stream_params,
-                              cubeb_devid output_device,
-                              cubeb_stream_params * output_stream_params,
-                              unsigned int latency_frames,
-                              cubeb_data_callback data_callback,
-                              cubeb_state_callback state_callback,
-                              void * user_ptr);
-static void cbjack_stream_destroy(cubeb_stream * stream);
-static int cbjack_stream_start(cubeb_stream * stream);
-static int cbjack_stream_stop(cubeb_stream * stream);
-static int cbjack_stream_get_position(cubeb_stream * stream, uint64_t * position);
-static int cbjack_stream_set_volume(cubeb_stream * stm, float volume);
+static char const *
+cbjack_get_backend_id(cubeb * context);
+static int
+cbjack_get_max_channel_count(cubeb * ctx, uint32_t * max_channels);
+static int
+cbjack_get_min_latency(cubeb * ctx, cubeb_stream_params params,
+                       uint32_t * latency_frames);
+static int
+cbjack_get_latency(cubeb_stream * stm, unsigned int * latency_frames);
+static int
+cbjack_get_preferred_sample_rate(cubeb * ctx, uint32_t * rate);
+static void
+cbjack_destroy(cubeb * context);
+static void
+cbjack_interleave_capture(cubeb_stream * stream, float ** in,
+                          jack_nframes_t nframes, bool format_mismatch);
+static void
+cbjack_deinterleave_playback_refill_s16ne(cubeb_stream * stream,
+                                          short ** bufs_in, float ** bufs_out,
+                                          jack_nframes_t nframes);
+static void
+cbjack_deinterleave_playback_refill_float(cubeb_stream * stream,
+                                          float ** bufs_in, float ** bufs_out,
+                                          jack_nframes_t nframes);
+static int
+cbjack_stream_device_destroy(cubeb_stream * stream, cubeb_device * device);
+static int
+cbjack_stream_get_current_device(cubeb_stream * stm,
+                                 cubeb_device ** const device);
+static int
+cbjack_enumerate_devices(cubeb * context, cubeb_device_type type,
+                         cubeb_device_collection * collection);
+static int
+cbjack_device_collection_destroy(cubeb * context,
+                                 cubeb_device_collection * collection);
+static int
+cbjack_stream_init(cubeb * context, cubeb_stream ** stream,
+                   char const * stream_name, cubeb_devid input_device,
+                   cubeb_stream_params * input_stream_params,
+                   cubeb_devid output_device,
+                   cubeb_stream_params * output_stream_params,
+                   unsigned int latency_frames,
+                   cubeb_data_callback data_callback,
+                   cubeb_state_callback state_callback, void * user_ptr);
+static void
+cbjack_stream_destroy(cubeb_stream * stream);
+static int
+cbjack_stream_start(cubeb_stream * stream);
+static int
+cbjack_stream_stop(cubeb_stream * stream);
+static int
+cbjack_stream_get_position(cubeb_stream * stream, uint64_t * position);
+static int
+cbjack_stream_set_volume(cubeb_stream * stm, float volume);
 
 static struct cubeb_ops const cbjack_ops = {
-  .init = jack_init,
-  .get_backend_id = cbjack_get_backend_id,
-  .get_max_channel_count = cbjack_get_max_channel_count,
-  .get_min_latency = cbjack_get_min_latency,
-  .get_preferred_sample_rate = cbjack_get_preferred_sample_rate,
-  .enumerate_devices = cbjack_enumerate_devices,
-  .device_collection_destroy = cbjack_device_collection_destroy,
-  .destroy = cbjack_destroy,
-  .stream_init = cbjack_stream_init,
-  .stream_destroy = cbjack_stream_destroy,
-  .stream_start = cbjack_stream_start,
-  .stream_stop = cbjack_stream_stop,
-  .stream_get_position = cbjack_stream_get_position,
-  .stream_get_latency = cbjack_get_latency,
-  .stream_get_input_latency = NULL,
-  .stream_set_volume = cbjack_stream_set_volume,
-  .stream_set_name = NULL,
-  .stream_get_current_device = cbjack_stream_get_current_device,
-  .stream_device_destroy = cbjack_stream_device_destroy,
-  .stream_register_device_changed_callback = NULL,
-  .register_device_collection_changed = NULL
-};
+    .init = jack_init,
+    .get_backend_id = cbjack_get_backend_id,
+    .get_max_channel_count = cbjack_get_max_channel_count,
+    .get_min_latency = cbjack_get_min_latency,
+    .get_preferred_sample_rate = cbjack_get_preferred_sample_rate,
+    .enumerate_devices = cbjack_enumerate_devices,
+    .device_collection_destroy = cbjack_device_collection_destroy,
+    .destroy = cbjack_destroy,
+    .stream_init = cbjack_stream_init,
+    .stream_destroy = cbjack_stream_destroy,
+    .stream_start = cbjack_stream_start,
+    .stream_stop = cbjack_stream_stop,
+    .stream_get_position = cbjack_stream_get_position,
+    .stream_get_latency = cbjack_get_latency,
+    .stream_get_input_latency = NULL,
+    .stream_set_volume = cbjack_stream_set_volume,
+    .stream_set_name = NULL,
+    .stream_get_current_device = cbjack_stream_get_current_device,
+    .stream_device_destroy = cbjack_stream_device_destroy,
+    .stream_register_device_changed_callback = NULL,
+    .register_device_collection_changed = NULL};
 
 struct cubeb_stream {
   /* Note: Must match cubeb_stream layout in cubeb.c. */
@@ -155,7 +180,7 @@ struct cubeb_stream {
   /**< Mutex for each stream */
   pthread_mutex_t mutex;
 
-  bool in_use; /**< Set to false iff the stream is free */
+  bool in_use;      /**< Set to false iff the stream is free */
   bool ports_ready; /**< Set to true iff the JACK ports are ready */
 
   cubeb_data_callback data_callback;
@@ -214,11 +239,11 @@ load_jack_lib(cubeb * context)
   context->libjack = dlopen("libjack.0.dylib", RTLD_LAZY);
   context->libjack = dlopen("/usr/local/lib/libjack.0.dylib", RTLD_LAZY);
 #elif defined(__WIN32__)
-# ifdef _WIN64
-   context->libjack = LoadLibrary("libjack64.dll");
-# else
-   context->libjack = LoadLibrary("libjack.dll");
-# endif
+#ifdef _WIN64
+  context->libjack = LoadLibrary("libjack64.dll");
+#else
+  context->libjack = LoadLibrary("libjack.dll");
+#endif
 #else
   context->libjack = dlopen("libjack.so.0", RTLD_LAZY);
   if (!context->libjack) {
@@ -229,13 +254,13 @@ load_jack_lib(cubeb * context)
     return CUBEB_ERROR;
   }
 
-#define LOAD(x)                                           \
-  {                                                       \
-    api_##x = (decltype(x)*)dlsym(context->libjack, #x);  \
-    if (!api_##x) {                                       \
-      dlclose(context->libjack);                          \
-      return CUBEB_ERROR;                                 \
-    }                                                     \
+#define LOAD(x)                                                                \
+  {                                                                            \
+    api_##x = (decltype(x) *)dlsym(context->libjack, #x);                      \
+    if (!api_##x) {                                                            \
+      dlclose(context->libjack);                                               \
+      return CUBEB_ERROR;                                                      \
+    }                                                                          \
   }
 
   JACK_API_VISIT(LOAD);
@@ -245,40 +270,43 @@ load_jack_lib(cubeb * context)
 }
 
 static void
-cbjack_connect_port_out (cubeb_stream * stream, const size_t out_port, const char * const phys_in_port)
+cbjack_connect_port_out(cubeb_stream * stream, const size_t out_port,
+                        const char * const phys_in_port)
 {
-  const char *src_port = api_jack_port_name (stream->output_ports[out_port]);
+  const char * src_port = api_jack_port_name(stream->output_ports[out_port]);
 
-  api_jack_connect (stream->context->jack_client, src_port, phys_in_port);
+  api_jack_connect(stream->context->jack_client, src_port, phys_in_port);
 }
 
 static void
-cbjack_connect_port_in (cubeb_stream * stream, const char * const phys_out_port, size_t in_port)
+cbjack_connect_port_in(cubeb_stream * stream, const char * const phys_out_port,
+                       size_t in_port)
 {
-  const char *src_port = api_jack_port_name (stream->input_ports[in_port]);
+  const char * src_port = api_jack_port_name(stream->input_ports[in_port]);
 
-  api_jack_connect (stream->context->jack_client, phys_out_port, src_port);
+  api_jack_connect(stream->context->jack_client, phys_out_port, src_port);
 }
 
 static int
-cbjack_connect_ports (cubeb_stream * stream, enum cbjack_connect_ports_options options)
+cbjack_connect_ports(cubeb_stream * stream,
+                     enum cbjack_connect_ports_options options)
 {
   int r = CUBEB_ERROR;
-  const char ** phys_in_ports = api_jack_get_ports (stream->context->jack_client,
-                                                   NULL, NULL,
-                                                   JackPortIsInput
-                                                   | JackPortIsPhysical);
-  const char ** phys_out_ports = api_jack_get_ports (stream->context->jack_client,
-                                                    NULL, NULL,
-                                                    JackPortIsOutput
-                                                    | JackPortIsPhysical);
-
- if (phys_in_ports == NULL || *phys_in_ports == NULL || options & CBJACK_CP_OPTIONS_SKIP_OUTPUT) {
+  const char ** phys_in_ports =
+      api_jack_get_ports(stream->context->jack_client, NULL, NULL,
+                         JackPortIsInput | JackPortIsPhysical);
+  const char ** phys_out_ports =
+      api_jack_get_ports(stream->context->jack_client, NULL, NULL,
+                         JackPortIsOutput | JackPortIsPhysical);
+
+  if (phys_in_ports == NULL || *phys_in_ports == NULL ||
+      options & CBJACK_CP_OPTIONS_SKIP_OUTPUT) {
     goto skipplayback;
   }
 
   // Connect outputs to playback
-  for (unsigned int c = 0; c < stream->out_params.channels && phys_in_ports[c] != NULL; c++) {
+  for (unsigned int c = 0;
+       c < stream->out_params.channels && phys_in_ports[c] != NULL; c++) {
     cbjack_connect_port_out(stream, c, phys_in_ports[c]);
   }
 
@@ -290,11 +318,13 @@ cbjack_connect_ports (cubeb_stream * stream, enum cbjack_connect_ports_options o
   r = CUBEB_OK;
 
 skipplayback:
-  if (phys_out_ports == NULL || *phys_out_ports == NULL || options & CBJACK_CP_OPTIONS_SKIP_INPUT) {
+  if (phys_out_ports == NULL || *phys_out_ports == NULL ||
+      options & CBJACK_CP_OPTIONS_SKIP_INPUT) {
     goto end;
   }
   // Connect inputs to capture
-  for (unsigned int c = 0; c < stream->in_params.channels && phys_out_ports[c] != NULL; c++) {
+  for (unsigned int c = 0;
+       c < stream->in_params.channels && phys_out_ports[c] != NULL; c++) {
     cbjack_connect_port_in(stream, phys_out_ports[c], c);
   }
   r = CUBEB_OK;
@@ -314,7 +344,8 @@ cbjack_xrun_callback(void * arg)
   cubeb * ctx = (cubeb *)arg;
 
   float delay = api_jack_get_xrun_delayed_usecs(ctx->jack_client);
-  float fragments = ceilf(((delay / 1000000.0) * ctx->jack_sample_rate) / ctx->jack_buffer_size);
+  float fragments = ceilf(((delay / 1000000.0) * ctx->jack_sample_rate) /
+                          ctx->jack_buffer_size);
 
   ctx->jack_xruns += (unsigned int)fragments;
   return 0;
@@ -329,7 +360,7 @@ cbjack_graph_order_callback(void * arg)
   jack_nframes_t port_latency, max_latency = 0;
 
   for (int j = 0; j < MAX_STREAMS; j++) {
-    cubeb_stream *stm = &ctx->streams[j];
+    cubeb_stream * stm = &ctx->streams[j];
 
     if (!stm->in_use)
       continue;
@@ -337,10 +368,11 @@ cbjack_graph_order_callback(void * arg)
       continue;
 
     for (i = 0; i < (int)stm->out_params.channels; ++i) {
-      api_jack_port_get_latency_range(stm->output_ports[i], JackPlaybackLatency, &latency_range);
+      api_jack_port_get_latency_range(stm->output_ports[i], JackPlaybackLatency,
+                                      &latency_range);
       port_latency = latency_range.max;
       if (port_latency > max_latency)
-          max_latency = port_latency;
+        max_latency = port_latency;
     }
     /* Cap minimum latency to 128 frames */
     if (max_latency < 128)
@@ -362,9 +394,9 @@ cbjack_process(jack_nframes_t nframes, void * arg)
   ctx->jack_xruns = 0;
 
   for (int j = 0; j < MAX_STREAMS; j++) {
-    cubeb_stream *stm = &ctx->streams[j];
-    float *bufs_out[stm->out_params.channels];
-    float *bufs_in[stm->in_params.channels];
+    cubeb_stream * stm = &ctx->streams[j];
+    float * bufs_out[stm->out_params.channels];
+    float * bufs_in[stm->in_params.channels];
 
     if (!stm->in_use)
       continue;
@@ -378,18 +410,20 @@ cbjack_process(jack_nframes_t nframes, void * arg)
     if (stm->devs & OUT_ONLY) {
       // get jack output buffers
       for (i = 0; i < (int)stm->out_params.channels; i++)
-        bufs_out[i] = (float*)api_jack_port_get_buffer(stm->output_ports[i], nframes);
+        bufs_out[i] =
+            (float *)api_jack_port_get_buffer(stm->output_ports[i], nframes);
     }
     if (stm->devs & IN_ONLY) {
       // get jack input buffers
       for (i = 0; i < (int)stm->in_params.channels; i++)
-        bufs_in[i] = (float*)api_jack_port_get_buffer(stm->input_ports[i], nframes);
+        bufs_in[i] =
+            (float *)api_jack_port_get_buffer(stm->input_ports[i], nframes);
     }
     if (stm->pause) {
       // paused, play silence on output
       if (stm->devs & OUT_ONLY) {
         for (unsigned int c = 0; c < stm->out_params.channels; c++) {
-          float* buffer_out = bufs_out[c];
+          float * buffer_out = bufs_out[c];
           for (long f = 0; f < nframes; f++) {
             buffer_out[f] = 0.f;
           }
@@ -398,7 +432,7 @@ cbjack_process(jack_nframes_t nframes, void * arg)
       if (stm->devs & IN_ONLY) {
         // paused, capture silence
         for (unsigned int c = 0; c < stm->in_params.channels; c++) {
-          float* buffer_in = bufs_in[c];
+          float * buffer_in = bufs_in[c];
           for (long f = 0; f < nframes; f++) {
             buffer_in[f] = 0.f;
           }
@@ -409,31 +443,38 @@ cbjack_process(jack_nframes_t nframes, void * arg)
       // try to lock stream mutex
       if (pthread_mutex_trylock(&stm->mutex) == 0) {
 
-        int16_t *in_s16ne = stm->context->in_resampled_interleaved_buffer_s16ne;
-        float *in_float = stm->context->in_resampled_interleaved_buffer_float;
+        int16_t * in_s16ne =
+            stm->context->in_resampled_interleaved_buffer_s16ne;
+        float * in_float = stm->context->in_resampled_interleaved_buffer_float;
 
         // unpaused, play audio
         if (stm->devs == DUPLEX) {
           if (stm->out_params.format == CUBEB_SAMPLE_S16NE) {
             cbjack_interleave_capture(stm, bufs_in, nframes, true);
-            cbjack_deinterleave_playback_refill_s16ne(stm, &in_s16ne, bufs_out, nframes);
+            cbjack_deinterleave_playback_refill_s16ne(stm, &in_s16ne, bufs_out,
+                                                      nframes);
           } else if (stm->out_params.format == CUBEB_SAMPLE_FLOAT32NE) {
             cbjack_interleave_capture(stm, bufs_in, nframes, false);
-            cbjack_deinterleave_playback_refill_float(stm, &in_float, bufs_out, nframes);
+            cbjack_deinterleave_playback_refill_float(stm, &in_float, bufs_out,
+                                                      nframes);
           }
         } else if (stm->devs == IN_ONLY) {
           if (stm->in_params.format == CUBEB_SAMPLE_S16NE) {
             cbjack_interleave_capture(stm, bufs_in, nframes, true);
-            cbjack_deinterleave_playback_refill_s16ne(stm, &in_s16ne, nullptr, nframes);
+            cbjack_deinterleave_playback_refill_s16ne(stm, &in_s16ne, nullptr,
+                                                      nframes);
           } else if (stm->in_params.format == CUBEB_SAMPLE_FLOAT32NE) {
             cbjack_interleave_capture(stm, bufs_in, nframes, false);
-            cbjack_deinterleave_playback_refill_float(stm, &in_float, nullptr, nframes);
+            cbjack_deinterleave_playback_refill_float(stm, &in_float, nullptr,
+                                                      nframes);
           }
         } else if (stm->devs == OUT_ONLY) {
           if (stm->out_params.format == CUBEB_SAMPLE_S16NE) {
-            cbjack_deinterleave_playback_refill_s16ne(stm, nullptr, bufs_out, nframes);
+            cbjack_deinterleave_playback_refill_s16ne(stm, nullptr, bufs_out,
+                                                      nframes);
           } else if (stm->out_params.format == CUBEB_SAMPLE_FLOAT32NE) {
-            cbjack_deinterleave_playback_refill_float(stm, nullptr, bufs_out, nframes);
+            cbjack_deinterleave_playback_refill_float(stm, nullptr, bufs_out,
+                                                      nframes);
           }
         }
         // unlock stream mutex
@@ -444,7 +485,7 @@ cbjack_process(jack_nframes_t nframes, void * arg)
         // output silence
         if (stm->devs & OUT_ONLY) {
           for (unsigned int c = 0; c < stm->out_params.channels; c++) {
-            float* buffer_out = bufs_out[c];
+            float * buffer_out = bufs_out[c];
             for (long f = 0; f < nframes; f++) {
               buffer_out[f] = 0.f;
             }
@@ -453,7 +494,7 @@ cbjack_process(jack_nframes_t nframes, void * arg)
         if (stm->devs & IN_ONLY) {
           // capture silence
           for (unsigned int c = 0; c < stm->in_params.channels; c++) {
-            float* buffer_in = bufs_in[c];
+            float * buffer_in = bufs_in[c];
             for (long f = 0; f < nframes; f++) {
               buffer_in[f] = 0.f;
             }
@@ -466,7 +507,9 @@ cbjack_process(jack_nframes_t nframes, void * arg)
 }
 
 static void
-cbjack_deinterleave_playback_refill_float(cubeb_stream * stream, float ** in, float ** bufs_out, jack_nframes_t nframes)
+cbjack_deinterleave_playback_refill_float(cubeb_stream * stream, float ** in,
+                                          float ** bufs_out,
+                                          jack_nframes_t nframes)
 {
   float * out_interleaved_buffer = nullptr;
 
@@ -477,20 +520,24 @@ cbjack_deinterleave_playback_refill_float(cubeb_stream * stream, float ** in, fl
   long done_frames = 0;
   long input_frames_count = (in != NULL) ? nframes : 0;
 
-  done_frames = cubeb_resampler_fill(stream->resampler,
-                                     inptr,
-                                     &input_frames_count,
-                                     (bufs_out != NULL) ? stream->context->out_resampled_interleaved_buffer_float : NULL,
-                                     needed_frames);
+  done_frames = cubeb_resampler_fill(
+      stream->resampler, inptr, &input_frames_count,
+      (bufs_out != NULL)
+          ? stream->context->out_resampled_interleaved_buffer_float
+          : NULL,
+      needed_frames);
 
-  out_interleaved_buffer = stream->context->out_resampled_interleaved_buffer_float;
+  out_interleaved_buffer =
+      stream->context->out_resampled_interleaved_buffer_float;
 
   if (outptr) {
     // convert interleaved output buffers to contiguous buffers
     for (unsigned int c = 0; c < stream->out_params.channels; c++) {
-      float* buffer = bufs_out[c];
+      float * buffer = bufs_out[c];
       for (long f = 0; f < done_frames; f++) {
-        buffer[f] = out_interleaved_buffer[(f * stream->out_params.channels) + c] * stream->volume;
+        buffer[f] =
+            out_interleaved_buffer[(f * stream->out_params.channels) + c] *
+            stream->volume;
       }
       if (done_frames < needed_frames) {
         // draining
@@ -524,7 +571,9 @@ cbjack_deinterleave_playback_refill_float(cubeb_stream * stream, float ** in, fl
 }
 
 static void
-cbjack_deinterleave_playback_refill_s16ne(cubeb_stream * stream, short ** in, float ** bufs_out, jack_nframes_t nframes)
+cbjack_deinterleave_playback_refill_s16ne(cubeb_stream * stream, short ** in,
+                                          float ** bufs_out,
+                                          jack_nframes_t nframes)
 {
   float * out_interleaved_buffer = nullptr;
 
@@ -535,22 +584,28 @@ cbjack_deinterleave_playback_refill_s16ne(cubeb_stream * stream, short ** in, fl
   long done_frames = 0;
   long input_frames_count = (in != NULL) ? nframes : 0;
 
-  done_frames = cubeb_resampler_fill(stream->resampler,
-                                     inptr,
-                                     &input_frames_count,
-                                     (bufs_out != NULL) ? stream->context->out_resampled_interleaved_buffer_s16ne : NULL,
-                                     needed_frames);
+  done_frames = cubeb_resampler_fill(
+      stream->resampler, inptr, &input_frames_count,
+      (bufs_out != NULL)
+          ? stream->context->out_resampled_interleaved_buffer_s16ne
+          : NULL,
+      needed_frames);
 
-  s16ne_to_float(stream->context->out_resampled_interleaved_buffer_float, stream->context->out_resampled_interleaved_buffer_s16ne, done_frames * stream->out_params.channels);
+  s16ne_to_float(stream->context->out_resampled_interleaved_buffer_float,
+                 stream->context->out_resampled_interleaved_buffer_s16ne,
+                 done_frames * stream->out_params.channels);
 
-  out_interleaved_buffer = stream->context->out_resampled_interleaved_buffer_float;
+  out_interleaved_buffer =
+      stream->context->out_resampled_interleaved_buffer_float;
 
   if (outptr) {
     // convert interleaved output buffers to contiguous buffers
     for (unsigned int c = 0; c < stream->out_params.channels; c++) {
-      float* buffer = bufs_out[c];
+      float * buffer = bufs_out[c];
       for (long f = 0; f < done_frames; f++) {
-        buffer[f] = out_interleaved_buffer[(f * stream->out_params.channels) + c] * stream->volume;
+        buffer[f] =
+            out_interleaved_buffer[(f * stream->out_params.channels) + c] *
+            stream->volume;
       }
       if (done_frames < needed_frames) {
         // draining
@@ -584,20 +639,25 @@ cbjack_deinterleave_playback_refill_s16ne(cubeb_stream * stream, short ** in, fl
 }
 
 static void
-cbjack_interleave_capture(cubeb_stream * stream, float **in, jack_nframes_t nframes, bool format_mismatch)
+cbjack_interleave_capture(cubeb_stream * stream, float ** in,
+                          jack_nframes_t nframes, bool format_mismatch)
 {
-  float *in_buffer = stream->context->in_float_interleaved_buffer;
+  float * in_buffer = stream->context->in_float_interleaved_buffer;
 
   for (unsigned int c = 0; c < stream->in_params.channels; c++) {
     for (long f = 0; f < nframes; f++) {
-      in_buffer[(f * stream->in_params.channels) + c] = in[c][f] * stream->volume;
+      in_buffer[(f * stream->in_params.channels) + c] =
+          in[c][f] * stream->volume;
     }
   }
   if (format_mismatch) {
-    float_to_s16ne(stream->context->in_resampled_interleaved_buffer_s16ne, in_buffer, nframes * stream->in_params.channels);
+    float_to_s16ne(stream->context->in_resampled_interleaved_buffer_s16ne,
+                   in_buffer, nframes * stream->in_params.channels);
   } else {
-    memset(stream->context->in_resampled_interleaved_buffer_float, 0, (FIFO_SIZE * MAX_CHANNELS * 3) * sizeof(float));
-    memcpy(stream->context->in_resampled_interleaved_buffer_float, in_buffer, (FIFO_SIZE * MAX_CHANNELS * 2) * sizeof(float));
+    memset(stream->context->in_resampled_interleaved_buffer_float, 0,
+           (FIFO_SIZE * MAX_CHANNELS * 3) * sizeof(float));
+    memcpy(stream->context->in_resampled_interleaved_buffer_float, in_buffer,
+           (FIFO_SIZE * MAX_CHANNELS * 2) * sizeof(float));
   }
 }
 
@@ -607,7 +667,7 @@ silent_jack_error_callback(char const * /*msg*/)
 }
 
 /*static*/ int
-jack_init (cubeb ** context, char const * context_name)
+jack_init(cubeb ** context, char const * context_name)
 {
   int r;
 
@@ -638,9 +698,8 @@ jack_init (cubeb ** context, char const * context_name)
   if (context_name)
     jack_client_name = context_name;
 
-  ctx->jack_client = api_jack_client_open(jack_client_name,
-                                          JackNoStartServer,
-                                          NULL);
+  ctx->jack_client =
+      api_jack_client_open(jack_client_name, JackNoStartServer, NULL);
 
   if (ctx->jack_client == NULL) {
     cbjack_destroy(ctx);
@@ -649,11 +708,12 @@ jack_init (cubeb ** context, char const * context_name)
 
   ctx->jack_xruns = 0;
 
-  api_jack_set_process_callback (ctx->jack_client, cbjack_process, ctx);
-  api_jack_set_xrun_callback (ctx->jack_client, cbjack_xrun_callback, ctx);
-  api_jack_set_graph_order_callback (ctx->jack_client, cbjack_graph_order_callback, ctx);
+  api_jack_set_process_callback(ctx->jack_client, cbjack_process, ctx);
+  api_jack_set_xrun_callback(ctx->jack_client, cbjack_xrun_callback, ctx);
+  api_jack_set_graph_order_callback(ctx->jack_client,
+                                    cbjack_graph_order_callback, ctx);
 
-  if (api_jack_activate (ctx->jack_client)) {
+  if (api_jack_activate(ctx->jack_client)) {
     cbjack_destroy(ctx);
     return CUBEB_ERROR;
   }
@@ -688,7 +748,8 @@ cbjack_get_latency(cubeb_stream * stm, unsigned int * latency_ms)
 }
 
 static int
-cbjack_get_min_latency(cubeb * ctx, cubeb_stream_params /*params*/, uint32_t * latency_ms)
+cbjack_get_min_latency(cubeb * ctx, cubeb_stream_params /*params*/,
+                       uint32_t * latency_ms)
 {
   *latency_ms = ctx->jack_latency;
   return CUBEB_OK;
@@ -698,9 +759,8 @@ static int
 cbjack_get_preferred_sample_rate(cubeb * ctx, uint32_t * rate)
 {
   if (!ctx->jack_client) {
-    jack_client_t * testclient = api_jack_client_open("test-samplerate",
-                                                 JackNoStartServer,
-                                                 NULL);
+    jack_client_t * testclient =
+        api_jack_client_open("test-samplerate", JackNoStartServer, NULL);
     if (!testclient) {
       return CUBEB_ERROR;
     }
@@ -720,7 +780,7 @@ cbjack_destroy(cubeb * context)
   context->active = false;
 
   if (context->jack_client != NULL)
-    api_jack_client_close (context->jack_client);
+    api_jack_client_close(context->jack_client);
 
   if (context->libjack)
     dlclose(context->libjack);
@@ -743,30 +803,27 @@ context_alloc_stream(cubeb * context, char const * stream_name)
 }
 
 static int
-cbjack_stream_init(cubeb * context, cubeb_stream ** stream, char const * stream_name,
-                   cubeb_devid input_device,
+cbjack_stream_init(cubeb * context, cubeb_stream ** stream,
+                   char const * stream_name, cubeb_devid input_device,
                    cubeb_stream_params * input_stream_params,
                    cubeb_devid output_device,
                    cubeb_stream_params * output_stream_params,
                    unsigned int /*latency_frames*/,
                    cubeb_data_callback data_callback,
-                   cubeb_state_callback state_callback,
-                   void * user_ptr)
+                   cubeb_state_callback state_callback, void * user_ptr)
 {
   int stream_actual_rate = 0;
   int jack_rate = api_jack_get_sample_rate(context->jack_client);
 
-  if (output_stream_params
-     && (output_stream_params->format != CUBEB_SAMPLE_FLOAT32NE &&
-         output_stream_params->format != CUBEB_SAMPLE_S16NE)
-     ) {
+  if (output_stream_params &&
+      (output_stream_params->format != CUBEB_SAMPLE_FLOAT32NE &&
+       output_stream_params->format != CUBEB_SAMPLE_S16NE)) {
     return CUBEB_ERROR_INVALID_FORMAT;
   }
 
-  if (input_stream_params
-     && (input_stream_params->format != CUBEB_SAMPLE_FLOAT32NE &&
-         input_stream_params->format != CUBEB_SAMPLE_S16NE)
-     ) {
+  if (input_stream_params &&
+      (input_stream_params->format != CUBEB_SAMPLE_FLOAT32NE &&
+       input_stream_params->format != CUBEB_SAMPLE_S16NE)) {
     return CUBEB_ERROR_INVALID_FORMAT;
   }
 
@@ -776,8 +833,10 @@ cbjack_stream_init(cubeb * context, cubeb_stream ** stream, char const * stream_
   }
 
   // Loopback is unsupported
-  if ((input_stream_params && (input_stream_params->prefs & CUBEB_STREAM_PREF_LOOPBACK)) ||
-      (output_stream_params && (output_stream_params->prefs & CUBEB_STREAM_PREF_LOOPBACK))) {
+  if ((input_stream_params &&
+       (input_stream_params->prefs & CUBEB_STREAM_PREF_LOOPBACK)) ||
+      (output_stream_params &&
+       (output_stream_params->prefs & CUBEB_STREAM_PREF_LOOPBACK))) {
     return CUBEB_ERROR_NOT_SUPPORTED;
   }
 
@@ -857,29 +916,17 @@ cbjack_stream_init(cubeb * context, cubeb_stream ** stream, char const * stream_
   stm->resampler = NULL;
 
   if (stm->devs == DUPLEX) {
-    stm->resampler = cubeb_resampler_create(stm,
-                                          &stm->in_params,
-                                          &stm->out_params,
-                                          stream_actual_rate,
-                                          stm->data_callback,
-                                          stm->user_ptr,
-                                          CUBEB_RESAMPLER_QUALITY_DESKTOP);
+    stm->resampler = cubeb_resampler_create(
+        stm, &stm->in_params, &stm->out_params, stream_actual_rate,
+        stm->data_callback, stm->user_ptr, CUBEB_RESAMPLER_QUALITY_DESKTOP);
   } else if (stm->devs == IN_ONLY) {
-    stm->resampler = cubeb_resampler_create(stm,
-                                          &stm->in_params,
-                                          nullptr,
-                                          stream_actual_rate,
-                                          stm->data_callback,
-                                          stm->user_ptr,
-                                          CUBEB_RESAMPLER_QUALITY_DESKTOP);
+    stm->resampler = cubeb_resampler_create(
+        stm, &stm->in_params, nullptr, stream_actual_rate, stm->data_callback,
+        stm->user_ptr, CUBEB_RESAMPLER_QUALITY_DESKTOP);
   } else if (stm->devs == OUT_ONLY) {
-    stm->resampler = cubeb_resampler_create(stm,
-                                          nullptr,
-                                          &stm->out_params,
-                                          stream_actual_rate,
-                                          stm->data_callback,
-                                          stm->user_ptr,
-                                          CUBEB_RESAMPLER_QUALITY_DESKTOP);
+    stm->resampler = cubeb_resampler_create(
+        stm, nullptr, &stm->out_params, stream_actual_rate, stm->data_callback,
+        stm->user_ptr, CUBEB_RESAMPLER_QUALITY_DESKTOP);
   }
 
   if (!stm->resampler) {
@@ -892,13 +939,13 @@ cbjack_stream_init(cubeb * context, cubeb_stream ** stream, char const * stream_
     for (unsigned int c = 0; c < stm->out_params.channels; c++) {
       char portname[256];
       snprintf(portname, 255, "%s_out_%d", stm->stream_name, c);
-      stm->output_ports[c] = api_jack_port_register(stm->context->jack_client,
-                                                    portname,
-                                                    JACK_DEFAULT_AUDIO_TYPE,
-                                                    JackPortIsOutput,
-                                                    0);
-      if (!(output_stream_params->prefs & CUBEB_STREAM_PREF_JACK_NO_AUTO_CONNECT)) {
-        if (cbjack_connect_ports(stm, CBJACK_CP_OPTIONS_SKIP_INPUT) != CUBEB_OK) {
+      stm->output_ports[c] =
+          api_jack_port_register(stm->context->jack_client, portname,
+                                 JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
+      if (!(output_stream_params->prefs &
+            CUBEB_STREAM_PREF_JACK_NO_AUTO_CONNECT)) {
+        if (cbjack_connect_ports(stm, CBJACK_CP_OPTIONS_SKIP_INPUT) !=
+            CUBEB_OK) {
           pthread_mutex_unlock(&stm->mutex);
           cbjack_stream_destroy(stm);
           return CUBEB_ERROR;
@@ -911,13 +958,13 @@ cbjack_stream_init(cubeb * context, cubeb_stream ** stream, char const * stream_
     for (unsigned int c = 0; c < stm->in_params.channels; c++) {
       char portname[256];
       snprintf(portname, 255, "%s_in_%d", stm->stream_name, c);
-      stm->input_ports[c] = api_jack_port_register(stm->context->jack_client,
-                                                    portname,
-                                                    JACK_DEFAULT_AUDIO_TYPE,
-                                                    JackPortIsInput,
-                                                    0);
-      if (!(input_stream_params->prefs & CUBEB_STREAM_PREF_JACK_NO_AUTO_CONNECT)) {
-        if (cbjack_connect_ports(stm, CBJACK_CP_OPTIONS_SKIP_OUTPUT) != CUBEB_OK) {
+      stm->input_ports[c] =
+          api_jack_port_register(stm->context->jack_client, portname,
+                                 JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
+      if (!(input_stream_params->prefs &
+            CUBEB_STREAM_PREF_JACK_NO_AUTO_CONNECT)) {
+        if (cbjack_connect_ports(stm, CBJACK_CP_OPTIONS_SKIP_OUTPUT) !=
+            CUBEB_OK) {
           pthread_mutex_unlock(&stm->mutex);
           cbjack_stream_destroy(stm);
           return CUBEB_ERROR;
@@ -944,7 +991,8 @@ cbjack_stream_destroy(cubeb_stream * stream)
   if (stream->devs == DUPLEX || stream->devs == OUT_ONLY) {
     for (unsigned int c = 0; c < stream->out_params.channels; c++) {
       if (stream->output_ports[c]) {
-        api_jack_port_unregister (stream->context->jack_client, stream->output_ports[c]);
+        api_jack_port_unregister(stream->context->jack_client,
+                                 stream->output_ports[c]);
         stream->output_ports[c] = NULL;
       }
     }
@@ -953,7 +1001,8 @@ cbjack_stream_destroy(cubeb_stream * stream)
   if (stream->devs == DUPLEX || stream->devs == IN_ONLY) {
     for (unsigned int c = 0; c < stream->in_params.channels; c++) {
       if (stream->input_ports[c]) {
-        api_jack_port_unregister (stream->context->jack_client, stream->input_ports[c]);
+        api_jack_port_unregister(stream->context->jack_client,
+                                 stream->input_ports[c]);
         stream->input_ports[c] = NULL;
       }
     }
@@ -998,7 +1047,8 @@ cbjack_stream_set_volume(cubeb_stream * stm, float volume)
 }
 
 static int
-cbjack_stream_get_current_device(cubeb_stream * stm, cubeb_device ** const device)
+cbjack_stream_get_current_device(cubeb_stream * stm,
+                                 cubeb_device ** const device)
 {
   *device = (cubeb_device *)calloc(1, sizeof(cubeb_device));
   if (*device == NULL)
@@ -1023,8 +1073,7 @@ cbjack_stream_get_current_device(cubeb_stream * stm, cubeb_device ** const devic
 }
 
 static int
-cbjack_stream_device_destroy(cubeb_stream * /*stream*/,
-                             cubeb_device * device)
+cbjack_stream_device_destroy(cubeb_stream * /*stream*/, cubeb_device * device)
 {
   if (device->input_name)
     free(device->input_name);
@@ -1053,7 +1102,7 @@ cbjack_enumerate_devices(cubeb * context, cubeb_device_type type,
   if (type & CUBEB_DEVICE_TYPE_OUTPUT) {
     cubeb_device_info * cur = &devices[collection->count];
     cur->device_id = JACK_DEFAULT_OUT;
-    cur->devid = (cubeb_devid) cur->device_id;
+    cur->devid = (cubeb_devid)cur->device_id;
     cur->friendly_name = JACK_DEFAULT_OUT;
     cur->group_id = JACK_DEFAULT_OUT;
     cur->vendor_name = JACK_DEFAULT_OUT;
@@ -1068,13 +1117,13 @@ cbjack_enumerate_devices(cubeb * context, cubeb_device_type type,
     cur->default_rate = rate;
     cur->latency_lo = 0;
     cur->latency_hi = 0;
-    collection->count +=1 ;
+    collection->count += 1;
   }
 
   if (type & CUBEB_DEVICE_TYPE_INPUT) {
     cubeb_device_info * cur = &devices[collection->count];
     cur->device_id = JACK_DEFAULT_IN;
-    cur->devid = (cubeb_devid) cur->device_id;
+    cur->devid = (cubeb_devid)cur->device_id;
     cur->friendly_name = JACK_DEFAULT_IN;
     cur->group_id = JACK_DEFAULT_IN;
     cur->vendor_name = JACK_DEFAULT_IN;
@@ -1102,6 +1151,6 @@ cbjack_device_collection_destroy(cubeb * /*ctx*/,
                                  cubeb_device_collection * collection)
 {
   XASSERT(collection);
-  delete [] collection->device;
+  delete[] collection->device;
   return CUBEB_OK;
 }
diff --git a/src/cubeb_kai.c b/src/cubeb_kai.c
index c563896..0a0d676 100644
--- a/src/cubeb_kai.c
+++ b/src/cubeb_kai.c
@@ -4,15 +4,15 @@
  * This program is made available under an ISC-style license.  See the
  * accompanying file LICENSE for details.
  */
+#include <math.h>
 #include <stdio.h>
 #include <string.h>
-#include <math.h>
 #include <sys/fmutex.h>
 
 #include <kai.h>
 
-#include "cubeb/cubeb.h"
 #include "cubeb-internal.h"
+#include "cubeb/cubeb.h"
 
 /* We don't support more than 2 channels in KAI */
 #define MAX_CHANNELS 2
@@ -59,7 +59,8 @@ bytes_to_frames(long bytes, cubeb_stream_params params)
   return bytes / 2 / params.channels; /* 2 bytes per frame */
 }
 
-static void kai_destroy(cubeb * ctx);
+static void
+kai_destroy(cubeb * ctx);
 
 /*static*/ int
 kai_init(cubeb ** context, char const * context_name)
@@ -97,7 +98,7 @@ kai_destroy(cubeb * ctx)
 }
 
 static void
-float_to_s16ne(int16_t *dst, float *src, size_t n)
+float_to_s16ne(int16_t * dst, float * src, size_t n)
 {
   long l;
 
@@ -115,14 +116,13 @@ static ULONG APIENTRY
 kai_callback(PVOID cbdata, PVOID buffer, ULONG len)
 {
   cubeb_stream * stm = cbdata;
-  void *p;
+  void * p;
   long wanted_frames;
   long frames;
   float soft_volume;
   int elements = len / sizeof(int16_t);
 
-  p = stm->params.format == CUBEB_SAMPLE_FLOAT32NE
-      ? stm->float_buffer : buffer;
+  p = stm->params.format == CUBEB_SAMPLE_FLOAT32NE ? stm->float_buffer : buffer;
 
   wanted_frames = bytes_to_frames(len, stm->params);
   frames = stm->data_callback(stm, stm->user_ptr, NULL, p, wanted_frames);
@@ -139,7 +139,7 @@ kai_callback(PVOID cbdata, PVOID buffer, ULONG len)
     float_to_s16ne(buffer, p, elements);
 
   if (soft_volume != -1.0f) {
-    int16_t *b = buffer;
+    int16_t * b = buffer;
     int i;
 
     for (i = 0; i < elements; i++)
@@ -149,12 +149,12 @@ kai_callback(PVOID cbdata, PVOID buffer, ULONG len)
   return frames_to_bytes(frames, stm->params);
 }
 
-static void kai_stream_destroy(cubeb_stream * stm);
+static void
+kai_stream_destroy(cubeb_stream * stm);
 
 static int
 kai_stream_init(cubeb * context, cubeb_stream ** stream,
-                char const * stream_name,
-                cubeb_devid input_device,
+                char const * stream_name, cubeb_devid input_device,
                 cubeb_stream_params * input_stream_params,
                 cubeb_devid output_device,
                 cubeb_stream_params * output_stream_params,
@@ -202,17 +202,17 @@ kai_stream_init(cubeb * context, cubeb_stream ** stream,
     return CUBEB_ERROR;
   }
 
-  wanted_spec.usDeviceIndex   = 0;
-  wanted_spec.ulType          = KAIT_PLAY;
+  wanted_spec.usDeviceIndex = 0;
+  wanted_spec.ulType = KAIT_PLAY;
   wanted_spec.ulBitsPerSample = BPS_16;
-  wanted_spec.ulSamplingRate  = stm->params.rate;
-  wanted_spec.ulDataFormat    = MCI_WAVE_FORMAT_PCM;
-  wanted_spec.ulChannels      = stm->params.channels;
-  wanted_spec.ulNumBuffers    = NBUFS;
-  wanted_spec.ulBufferSize    = frames_to_bytes(FRAME_SIZE, stm->params);
-  wanted_spec.fShareable      = TRUE;
-  wanted_spec.pfnCallBack     = kai_callback;
-  wanted_spec.pCallBackData   = stm;
+  wanted_spec.ulSamplingRate = stm->params.rate;
+  wanted_spec.ulDataFormat = MCI_WAVE_FORMAT_PCM;
+  wanted_spec.ulChannels = stm->params.channels;
+  wanted_spec.ulNumBuffers = NBUFS;
+  wanted_spec.ulBufferSize = frames_to_bytes(FRAME_SIZE, stm->params);
+  wanted_spec.fShareable = TRUE;
+  wanted_spec.pfnCallBack = kai_callback;
+  wanted_spec.pCallBackData = stm;
 
   if (kaiOpen(&wanted_spec, &stm->spec, &stm->hkai)) {
     _fmutex_close(&stm->mutex);
@@ -265,17 +265,17 @@ kai_get_preferred_sample_rate(cubeb * ctx, uint32_t * rate)
   params.rate = 48000;
   params.channels = 2;
 
-  wanted_spec.usDeviceIndex   = 0;
-  wanted_spec.ulType          = KAIT_PLAY;
+  wanted_spec.usDeviceIndex = 0;
+  wanted_spec.ulType = KAIT_PLAY;
   wanted_spec.ulBitsPerSample = BPS_16;
-  wanted_spec.ulSamplingRate  = params.rate;
-  wanted_spec.ulDataFormat    = MCI_WAVE_FORMAT_PCM;
-  wanted_spec.ulChannels      = params.channels;
-  wanted_spec.ulNumBuffers    = NBUFS;
-  wanted_spec.ulBufferSize    = frames_to_bytes(FRAME_SIZE, params);
-  wanted_spec.fShareable      = TRUE;
-  wanted_spec.pfnCallBack     = kai_callback;
-  wanted_spec.pCallBackData   = NULL;
+  wanted_spec.ulSamplingRate = params.rate;
+  wanted_spec.ulDataFormat = MCI_WAVE_FORMAT_PCM;
+  wanted_spec.ulChannels = params.channels;
+  wanted_spec.ulNumBuffers = NBUFS;
+  wanted_spec.ulBufferSize = frames_to_bytes(FRAME_SIZE, params);
+  wanted_spec.fShareable = TRUE;
+  wanted_spec.pfnCallBack = kai_callback;
+  wanted_spec.pCallBackData = NULL;
 
   /* Test 48KHz */
   if (kaiOpen(&wanted_spec, &spec, &hkai)) {
@@ -328,8 +328,8 @@ kai_stream_get_latency(cubeb_stream * stm, uint32_t * latency)
 {
   /* Out of buffers, one is being played, the others are being filled.
      So there is as much latency as total buffers - 1. */
-  *latency = bytes_to_frames(stm->spec.ulBufferSize, stm->params)
-             * (stm->spec.ulNumBuffers - 1);
+  *latency = bytes_to_frames(stm->spec.ulBufferSize, stm->params) *
+             (stm->spec.ulNumBuffers - 1);
 
   return CUBEB_OK;
 }
@@ -345,26 +345,25 @@ kai_stream_set_volume(cubeb_stream * stm, float volume)
 }
 
 static struct cubeb_ops const kai_ops = {
-  /*.init =*/ kai_init,
-  /*.get_backend_id =*/ kai_get_backend_id,
-  /*.get_max_channel_count=*/ kai_get_max_channel_count,
-  /*.get_min_latency=*/ kai_get_min_latency,
-  /*.get_preferred_sample_rate =*/ kai_get_preferred_sample_rate,
-  /*.get_preferred_channel_layout =*/ NULL,
-  /*.enumerate_devices =*/ NULL,
-  /*.device_collection_destroy =*/ NULL,
-  /*.destroy =*/ kai_destroy,
-  /*.stream_init =*/ kai_stream_init,
-  /*.stream_destroy =*/ kai_stream_destroy,
-  /*.stream_start =*/ kai_stream_start,
-  /*.stream_stop =*/ kai_stream_stop,
-  /*.stream_get_position =*/ kai_stream_get_position,
-  /*.stream_get_latency = */ kai_stream_get_latency,
-  /*.stream_get_input_latency = */ NULL,
-  /*.stream_set_volume =*/ kai_stream_set_volume,
-  /*.stream_set_name =*/ NULL,
-  /*.stream_get_current_device =*/ NULL,
-  /*.stream_device_destroy =*/ NULL,
-  /*.stream_register_device_changed_callback=*/ NULL,
-  /*.register_device_collection_changed=*/ NULL
-};
+    /*.init =*/kai_init,
+    /*.get_backend_id =*/kai_get_backend_id,
+    /*.get_max_channel_count=*/kai_get_max_channel_count,
+    /*.get_min_latency=*/kai_get_min_latency,
+    /*.get_preferred_sample_rate =*/kai_get_preferred_sample_rate,
+    /*.get_preferred_channel_layout =*/NULL,
+    /*.enumerate_devices =*/NULL,
+    /*.device_collection_destroy =*/NULL,
+    /*.destroy =*/kai_destroy,
+    /*.stream_init =*/kai_stream_init,
+    /*.stream_destroy =*/kai_stream_destroy,
+    /*.stream_start =*/kai_stream_start,
+    /*.stream_stop =*/kai_stream_stop,
+    /*.stream_get_position =*/kai_stream_get_position,
+    /*.stream_get_latency = */ kai_stream_get_latency,
+    /*.stream_get_input_latency = */ NULL,
+    /*.stream_set_volume =*/kai_stream_set_volume,
+    /*.stream_set_name =*/NULL,
+    /*.stream_get_current_device =*/NULL,
+    /*.stream_device_destroy =*/NULL,
+    /*.stream_register_device_changed_callback=*/NULL,
+    /*.register_device_collection_changed=*/NULL};
diff --git a/src/cubeb_log.cpp b/src/cubeb_log.cpp
index 54c7f4a..ff72e0e 100644
--- a/src/cubeb_log.cpp
+++ b/src/cubeb_log.cpp
@@ -27,17 +27,13 @@ const size_t CUBEB_LOG_MESSAGE_QUEUE_DEPTH = 40;
 #define CUBEB_LOG_BATCH_PRINT_INTERVAL_MS 10
 
 /**
-  * This wraps an inline buffer, that represents a log message, that must be
-  * null-terminated.
-  * This class should not use system calls or other potentially blocking code.
-  */
-class cubeb_log_message
-{
+ * This wraps an inline buffer, that represents a log message, that must be
+ * null-terminated.
+ * This class should not use system calls or other potentially blocking code.
+ */
+class cubeb_log_message {
 public:
-  cubeb_log_message()
-  {
-    *storage = '\0';
-  }
+  cubeb_log_message() { *storage = '\0'; }
   cubeb_log_message(char const str[CUBEB_LOG_MESSAGE_MAX_SIZE])
   {
     size_t length = strlen(str);
@@ -49,20 +45,19 @@ public:
     PodCopy(storage, str, length);
     storage[length] = '\0';
   }
-  char const * get() {
-    return storage;
-  }
+  char const * get() { return storage; }
+
 private:
   char storage[CUBEB_LOG_MESSAGE_MAX_SIZE];
 };
 
 /** Lock-free asynchronous logger, made so that logging from a
  *  real-time audio callback does not block the audio thread. */
-class cubeb_async_logger
-{
+class cubeb_async_logger {
 public:
   /* This is thread-safe since C++11 */
-  static cubeb_async_logger & get() {
+  static cubeb_async_logger & get()
+  {
     static cubeb_async_logger instance;
     return instance;
   }
@@ -85,8 +80,7 @@ public:
         timespec sleep_duration = sleep_for;
         timespec remainder;
         do {
-          if (nanosleep(&sleep_duration, &remainder) == 0 ||
-              errno != EINTR) {
+          if (nanosleep(&sleep_duration, &remainder) == 0 || errno != EINTR) {
             break;
           }
           sleep_duration = remainder;
@@ -97,29 +91,22 @@ public:
   }
   // Tell the underlying queue the producer thread has changed, so it does not
   // assert in debug. This should be called with the thread stopped.
-  void reset_producer_thread()
-  {
-    msg_queue.reset_thread_ids();
-  }
+  void reset_producer_thread() { msg_queue.reset_thread_ids(); }
+
 private:
 #ifndef _WIN32
   const struct timespec sleep_for = {
-    CUBEB_LOG_BATCH_PRINT_INTERVAL_MS/1000,
-    (CUBEB_LOG_BATCH_PRINT_INTERVAL_MS%1000)*1000*1000
-  };
+      CUBEB_LOG_BATCH_PRINT_INTERVAL_MS / 1000,
+      (CUBEB_LOG_BATCH_PRINT_INTERVAL_MS % 1000) * 1000 * 1000};
 #endif
-  cubeb_async_logger()
-    : msg_queue(CUBEB_LOG_MESSAGE_QUEUE_DEPTH)
-  {
-    run();
-  }
+  cubeb_async_logger() : msg_queue(CUBEB_LOG_MESSAGE_QUEUE_DEPTH) { run(); }
   /** This is quite a big data structure, but is only instantiated if the
    * asynchronous logger is used.*/
   lock_free_queue<cubeb_log_message> msg_queue;
 };
 
-
-void cubeb_async_log(char const * fmt, ...)
+void
+cubeb_async_log(char const * fmt, ...)
 {
   if (!g_cubeb_log_callback) {
     return;
@@ -135,7 +122,8 @@ void cubeb_async_log(char const * fmt, ...)
   va_end(args);
 }
 
-void cubeb_async_log_reset_threads()
+void
+cubeb_async_log_reset_threads()
 {
   if (!g_cubeb_log_callback) {
     return;
diff --git a/src/cubeb_log.h b/src/cubeb_log.h
index 4139196..aee3180 100644
--- a/src/cubeb_log.h
+++ b/src/cubeb_log.h
@@ -19,18 +19,23 @@ extern "C" {
 #if defined(__FILE_NAME__)
 #define __FILENAME__ __FILE_NAME__
 #else
-#define __FILENAME__ (__builtin_strrchr(__FILE__, '/') ? __builtin_strrchr(__FILE__, '/') + 1 : __FILE__)
+#define __FILENAME__                                                           \
+  (__builtin_strrchr(__FILE__, '/') ? __builtin_strrchr(__FILE__, '/') + 1     \
+                                    : __FILE__)
 #endif
 #else
 #define PRINTF_FORMAT(fmt, args)
 #include <string.h>
-#define __FILENAME__ (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
+#define __FILENAME__                                                           \
+  (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
 #endif
 
 extern cubeb_log_level g_cubeb_log_level;
 extern cubeb_log_callback g_cubeb_log_callback PRINTF_FORMAT(1, 2);
-void cubeb_async_log(const char * fmt, ...);
-void cubeb_async_log_reset_threads();
+void
+cubeb_async_log(const char * fmt, ...);
+void
+cubeb_async_log_reset_threads();
 
 #ifdef __cplusplus
 }
@@ -39,17 +44,19 @@ void cubeb_async_log_reset_threads();
 #define LOGV(msg, ...) LOG_INTERNAL(CUBEB_LOG_VERBOSE, msg, ##__VA_ARGS__)
 #define LOG(msg, ...) LOG_INTERNAL(CUBEB_LOG_NORMAL, msg, ##__VA_ARGS__)
 
-#define LOG_INTERNAL(level, fmt, ...) do {                                              \
-    if (g_cubeb_log_callback && level <= g_cubeb_log_level) {                           \
-      g_cubeb_log_callback("%s:%d: " fmt "\n",  __FILENAME__, __LINE__, ##__VA_ARGS__); \
-    }                                                                                   \
-  } while(0)
+#define LOG_INTERNAL(level, fmt, ...)                                          \
+  do {                                                                         \
+    if (g_cubeb_log_callback && level <= g_cubeb_log_level) {                  \
+      g_cubeb_log_callback("%s:%d: " fmt "\n", __FILENAME__, __LINE__,         \
+                           ##__VA_ARGS__);                                     \
+    }                                                                          \
+  } while (0)
 
 /* Asynchronous verbose logging, to log in real-time callbacks. */
 /* Should not be used on android due to the use of global/static variables. */
-#define ALOGV(fmt, ...)                   \
-do {                                      \
-  cubeb_async_log(fmt, ##__VA_ARGS__);    \
-} while(0)
+#define ALOGV(fmt, ...)                                                        \
+  do {                                                                         \
+    cubeb_async_log(fmt, ##__VA_ARGS__);                                       \
+  } while (0)
 
 #endif // CUBEB_LOG
diff --git a/src/cubeb_mixer.cpp b/src/cubeb_mixer.cpp
index 2ab7f67..343e0e2 100644
--- a/src/cubeb_mixer.cpp
+++ b/src/cubeb_mixer.cpp
@@ -9,6 +9,9 @@
 
 #define NOMINMAX
 
+#include "cubeb_mixer.h"
+#include "cubeb-internal.h"
+#include "cubeb_utils.h"
 #include <algorithm>
 #include <cassert>
 #include <climits>
@@ -16,67 +19,67 @@
 #include <cstdlib>
 #include <memory>
 #include <type_traits>
-#include "cubeb-internal.h"
-#include "cubeb_mixer.h"
-#include "cubeb_utils.h"
 
 #ifndef FF_ARRAY_ELEMS
 #define FF_ARRAY_ELEMS(a) (sizeof(a) / sizeof((a)[0]))
 #endif
 
 #define CHANNELS_MAX 32
-#define FRONT_LEFT             0
-#define FRONT_RIGHT            1
-#define FRONT_CENTER           2
-#define LOW_FREQUENCY          3
-#define BACK_LEFT              4
-#define BACK_RIGHT             5
-#define FRONT_LEFT_OF_CENTER   6
-#define FRONT_RIGHT_OF_CENTER  7
-#define BACK_CENTER            8
-#define SIDE_LEFT              9
-#define SIDE_RIGHT             10
-#define TOP_CENTER             11
-#define TOP_FRONT_LEFT         12
-#define TOP_FRONT_CENTER       13
-#define TOP_FRONT_RIGHT        14
-#define TOP_BACK_LEFT          15
-#define TOP_BACK_CENTER        16
-#define TOP_BACK_RIGHT         17
-#define NUM_NAMED_CHANNELS     18
+#define FRONT_LEFT 0
+#define FRONT_RIGHT 1
+#define FRONT_CENTER 2
+#define LOW_FREQUENCY 3
+#define BACK_LEFT 4
+#define BACK_RIGHT 5
+#define FRONT_LEFT_OF_CENTER 6
+#define FRONT_RIGHT_OF_CENTER 7
+#define BACK_CENTER 8
+#define SIDE_LEFT 9
+#define SIDE_RIGHT 10
+#define TOP_CENTER 11
+#define TOP_FRONT_LEFT 12
+#define TOP_FRONT_CENTER 13
+#define TOP_FRONT_RIGHT 14
+#define TOP_BACK_LEFT 15
+#define TOP_BACK_CENTER 16
+#define TOP_BACK_RIGHT 17
+#define NUM_NAMED_CHANNELS 18
 
 #ifndef M_SQRT1_2
-#define M_SQRT1_2      0.70710678118654752440  /* 1/sqrt(2) */
+#define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */
 #endif
 #ifndef M_SQRT2
-#define M_SQRT2        1.41421356237309504880  /* sqrt(2) */
+#define M_SQRT2 1.41421356237309504880 /* sqrt(2) */
 #endif
-#define SQRT3_2      1.22474487139158904909  /* sqrt(3/2) */
+#define SQRT3_2 1.22474487139158904909 /* sqrt(3/2) */
 
-#define  C30DB  M_SQRT2
-#define  C15DB  1.189207115
-#define C__0DB  1.0
-#define C_15DB  0.840896415
-#define C_30DB  M_SQRT1_2
-#define C_45DB  0.594603558
-#define C_60DB  0.5
+#define C30DB M_SQRT2
+#define C15DB 1.189207115
+#define C__0DB 1.0
+#define C_15DB 0.840896415
+#define C_30DB M_SQRT1_2
+#define C_45DB 0.594603558
+#define C_60DB 0.5
 
 static cubeb_channel_layout
 cubeb_channel_layout_check(cubeb_channel_layout l, uint32_t c)
 {
-    if (l == CUBEB_LAYOUT_UNDEFINED) {
-      switch (c) {
-        case 1: return CUBEB_LAYOUT_MONO;
-        case 2: return CUBEB_LAYOUT_STEREO;
-      }
+  if (l == CUBEB_LAYOUT_UNDEFINED) {
+    switch (c) {
+    case 1:
+      return CUBEB_LAYOUT_MONO;
+    case 2:
+      return CUBEB_LAYOUT_STEREO;
     }
-    return l;
+  }
+  return l;
 }
 
-unsigned int cubeb_channel_layout_nb_channels(cubeb_channel_layout x)
+unsigned int
+cubeb_channel_layout_nb_channels(cubeb_channel_layout x)
 {
 #if __GNUC__ || __clang__
-  return __builtin_popcount (x);
+  return __builtin_popcount(x);
 #else
   x -= (x >> 1) & 0x55555555;
   x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
@@ -87,16 +90,12 @@ unsigned int cubeb_channel_layout_nb_channels(cubeb_channel_layout x)
 }
 
 struct MixerContext {
-  MixerContext(cubeb_sample_format f,
-               uint32_t in_channels,
-               cubeb_channel_layout in,
-               uint32_t out_channels,
+  MixerContext(cubeb_sample_format f, uint32_t in_channels,
+               cubeb_channel_layout in, uint32_t out_channels,
                cubeb_channel_layout out)
-    : _format(f)
-    , _in_ch_layout(cubeb_channel_layout_check(in, in_channels))
-    , _out_ch_layout(cubeb_channel_layout_check(out, out_channels))
-    , _in_ch_count(in_channels)
-    , _out_ch_count(out_channels)
+      : _format(f), _in_ch_layout(cubeb_channel_layout_check(in, in_channels)),
+        _out_ch_layout(cubeb_channel_layout_check(out, out_channels)),
+        _in_ch_count(in_channels), _out_ch_count(out_channels)
   {
     if (in_channels != cubeb_channel_layout_nb_channels(in) ||
         out_channels != cubeb_channel_layout_nb_channels(out)) {
@@ -159,24 +158,30 @@ struct MixerContext {
   int init();
 
   const cubeb_sample_format _format;
-  const cubeb_channel_layout _in_ch_layout;              ///< input channel layout
-  const cubeb_channel_layout _out_ch_layout;             ///< output channel layout
-  const uint32_t _in_ch_count;                           ///< input channel count
-  const uint32_t _out_ch_count;                          ///< output channel count
-  const float _surround_mix_level = C_30DB;              ///< surround mixing level
-  const float _center_mix_level = C_30DB;                ///< center mixing level
-  const float _lfe_mix_level = 1;                        ///< LFE mixing level
-  double _matrix[CHANNELS_MAX][CHANNELS_MAX] = {{ 0 }};        ///< floating point rematrixing coefficients
-  float _matrix_flt[CHANNELS_MAX][CHANNELS_MAX] = {{ 0 }};     ///< single precision floating point rematrixing coefficients
-  int32_t _matrix32[CHANNELS_MAX][CHANNELS_MAX] = {{ 0 }};     ///< 17.15 fixed point rematrixing coefficients
-  uint8_t _matrix_ch[CHANNELS_MAX][CHANNELS_MAX+1] = {{ 0 }};  ///< Lists of input channels per output channel that have non zero rematrixing coefficients
-  bool _clipping = false;                          ///< Set to true if clipping detection is required
-  bool _valid = false;                             ///< Set to true if context is valid.
+  const cubeb_channel_layout _in_ch_layout;  ///< input channel layout
+  const cubeb_channel_layout _out_ch_layout; ///< output channel layout
+  const uint32_t _in_ch_count;               ///< input channel count
+  const uint32_t _out_ch_count;              ///< output channel count
+  const float _surround_mix_level = C_30DB;  ///< surround mixing level
+  const float _center_mix_level = C_30DB;    ///< center mixing level
+  const float _lfe_mix_level = 1;            ///< LFE mixing level
+  double _matrix[CHANNELS_MAX][CHANNELS_MAX] = {
+      {0}}; ///< floating point rematrixing coefficients
+  float _matrix_flt[CHANNELS_MAX][CHANNELS_MAX] = {
+      {0}}; ///< single precision floating point rematrixing coefficients
+  int32_t _matrix32[CHANNELS_MAX][CHANNELS_MAX] = {
+      {0}}; ///< 17.15 fixed point rematrixing coefficients
+  uint8_t _matrix_ch[CHANNELS_MAX][CHANNELS_MAX + 1] = {
+      {0}}; ///< Lists of input channels per output channel that have non zero
+            ///< rematrixing coefficients
+  bool _clipping = false; ///< Set to true if clipping detection is required
+  bool _valid = false;    ///< Set to true if context is valid.
 };
 
-int MixerContext::auto_matrix()
+int
+MixerContext::auto_matrix()
 {
-  double matrix[NUM_NAMED_CHANNELS][NUM_NAMED_CHANNELS] = { { 0 } };
+  double matrix[NUM_NAMED_CHANNELS][NUM_NAMED_CHANNELS] = {{0}};
   double maxcoef = 0;
   float maxval;
 
@@ -239,8 +244,7 @@ int MixerContext::auto_matrix()
       matrix[FRONT_LEFT][BACK_CENTER] += _surround_mix_level * M_SQRT1_2;
       matrix[FRONT_RIGHT][BACK_CENTER] += _surround_mix_level * M_SQRT1_2;
     } else if (out_ch_layout & CHANNEL_FRONT_CENTER) {
-      matrix[FRONT_CENTER][BACK_CENTER] +=
-        _surround_mix_level * M_SQRT1_2;
+      matrix[FRONT_CENTER][BACK_CENTER] += _surround_mix_level * M_SQRT1_2;
     }
   }
   if (unaccounted & CHANNEL_BACK_LEFT) {
@@ -321,7 +325,7 @@ int MixerContext::auto_matrix()
         _matrix[out_i][in_i] = matrix[i][j];
       } else {
         _matrix[out_i][in_i] =
-          i == j && (in_ch_layout & out_ch_layout & (1U << i));
+            i == j && (in_ch_layout & out_ch_layout & (1U << i));
       }
       sum += fabs(_matrix[out_i][in_i]);
       in_i++;
@@ -356,7 +360,8 @@ int MixerContext::auto_matrix()
   return 0;
 }
 
-int MixerContext::init()
+int
+MixerContext::init()
 {
   int r = auto_matrix();
   if (r) {
@@ -398,22 +403,16 @@ int MixerContext::init()
   return 0;
 }
 
-template<typename TYPE_SAMPLE, typename TYPE_COEFF, typename F>
+template <typename TYPE_SAMPLE, typename TYPE_COEFF, typename F>
 void
-sum2(TYPE_SAMPLE * out,
-     uint32_t stride_out,
-     const TYPE_SAMPLE * in1,
-     const TYPE_SAMPLE * in2,
-     uint32_t stride_in,
-     TYPE_COEFF coeff1,
-     TYPE_COEFF coeff2,
-     F&& operand,
-     uint32_t frames)
+sum2(TYPE_SAMPLE * out, uint32_t stride_out, const TYPE_SAMPLE * in1,
+     const TYPE_SAMPLE * in2, uint32_t stride_in, TYPE_COEFF coeff1,
+     TYPE_COEFF coeff2, F && operand, uint32_t frames)
 {
   static_assert(
-    std::is_same<TYPE_COEFF,
-                 typename std::result_of<F(TYPE_COEFF)>::type>::value,
-    "function must return the same type as used by matrix_coeff");
+      std::is_same<TYPE_COEFF,
+                   typename std::result_of<F(TYPE_COEFF)>::type>::value,
+      "function must return the same type as used by matrix_coeff");
   for (uint32_t i = 0; i < frames; i++) {
     *out = operand(coeff1 * *in1 + coeff2 * *in2);
     out += stride_out;
@@ -422,20 +421,15 @@ sum2(TYPE_SAMPLE * out,
   }
 }
 
-template<typename TYPE_SAMPLE, typename TYPE_COEFF, typename F>
+template <typename TYPE_SAMPLE, typename TYPE_COEFF, typename F>
 void
-copy(TYPE_SAMPLE * out,
-     uint32_t stride_out,
-     const TYPE_SAMPLE * in,
-     uint32_t stride_in,
-     TYPE_COEFF coeff,
-     F&& operand,
-     uint32_t frames)
+copy(TYPE_SAMPLE * out, uint32_t stride_out, const TYPE_SAMPLE * in,
+     uint32_t stride_in, TYPE_COEFF coeff, F && operand, uint32_t frames)
 {
   static_assert(
-    std::is_same<TYPE_COEFF,
-                 typename std::result_of<F(TYPE_COEFF)>::type>::value,
-    "function must return the same type as used by matrix_coeff");
+      std::is_same<TYPE_COEFF,
+                   typename std::result_of<F(TYPE_COEFF)>::type>::value,
+      "function must return the same type as used by matrix_coeff");
   for (uint32_t i = 0; i < frames; i++) {
     *out = operand(coeff * *in);
     out += stride_out;
@@ -444,74 +438,59 @@ copy(TYPE_SAMPLE * out,
 }
 
 template <typename TYPE, typename TYPE_COEFF, size_t COLS, typename F>
-static int rematrix(const MixerContext * s, TYPE * aOut, const TYPE * aIn,
-                    const TYPE_COEFF (&matrix_coeff)[COLS][COLS],
-                    F&& aF, uint32_t frames)
+static int
+rematrix(const MixerContext * s, TYPE * aOut, const TYPE * aIn,
+         const TYPE_COEFF (&matrix_coeff)[COLS][COLS], F && aF, uint32_t frames)
 {
   static_assert(
-    std::is_same<TYPE_COEFF,
-                 typename std::result_of<F(TYPE_COEFF)>::type>::value,
-    "function must return the same type as used by matrix_coeff");
+      std::is_same<TYPE_COEFF,
+                   typename std::result_of<F(TYPE_COEFF)>::type>::value,
+      "function must return the same type as used by matrix_coeff");
 
   for (uint32_t out_i = 0; out_i < s->_out_ch_count; out_i++) {
-    TYPE* out = aOut + out_i;
+    TYPE * out = aOut + out_i;
     switch (s->_matrix_ch[out_i][0]) {
-      case 0:
-        for (uint32_t i = 0; i < frames; i++) {
-          out[i * s->_out_ch_count] = 0;
-        }
-        break;
-      case 1: {
-        int in_i = s->_matrix_ch[out_i][1];
-        copy(out,
-             s->_out_ch_count,
-             aIn + in_i,
-             s->_in_ch_count,
-             matrix_coeff[out_i][in_i],
-             aF,
-             frames);
-      } break;
-      case 2:
-        sum2(out,
-             s->_out_ch_count,
-             aIn + s->_matrix_ch[out_i][1],
-             aIn + s->_matrix_ch[out_i][2],
-             s->_in_ch_count,
-             matrix_coeff[out_i][s->_matrix_ch[out_i][1]],
-             matrix_coeff[out_i][s->_matrix_ch[out_i][2]],
-             aF,
-             frames);
-        break;
-      default:
-        for (uint32_t i = 0; i < frames; i++) {
-          TYPE_COEFF v = 0;
-          for (uint32_t j = 0; j < s->_matrix_ch[out_i][0]; j++) {
-            uint32_t in_i = s->_matrix_ch[out_i][1 + j];
-            v +=
-              *(aIn + in_i + i * s->_in_ch_count) * matrix_coeff[out_i][in_i];
-          }
-          out[i * s->_out_ch_count] = aF(v);
+    case 0:
+      for (uint32_t i = 0; i < frames; i++) {
+        out[i * s->_out_ch_count] = 0;
+      }
+      break;
+    case 1: {
+      int in_i = s->_matrix_ch[out_i][1];
+      copy(out, s->_out_ch_count, aIn + in_i, s->_in_ch_count,
+           matrix_coeff[out_i][in_i], aF, frames);
+    } break;
+    case 2:
+      sum2(out, s->_out_ch_count, aIn + s->_matrix_ch[out_i][1],
+           aIn + s->_matrix_ch[out_i][2], s->_in_ch_count,
+           matrix_coeff[out_i][s->_matrix_ch[out_i][1]],
+           matrix_coeff[out_i][s->_matrix_ch[out_i][2]], aF, frames);
+      break;
+    default:
+      for (uint32_t i = 0; i < frames; i++) {
+        TYPE_COEFF v = 0;
+        for (uint32_t j = 0; j < s->_matrix_ch[out_i][0]; j++) {
+          uint32_t in_i = s->_matrix_ch[out_i][1 + j];
+          v += *(aIn + in_i + i * s->_in_ch_count) * matrix_coeff[out_i][in_i];
         }
-        break;
+        out[i * s->_out_ch_count] = aF(v);
+      }
+      break;
     }
   }
   return 0;
 }
 
-struct cubeb_mixer
-{
-  cubeb_mixer(cubeb_sample_format format,
-              uint32_t in_channels,
-              cubeb_channel_layout in_layout,
-              uint32_t out_channels,
+struct cubeb_mixer {
+  cubeb_mixer(cubeb_sample_format format, uint32_t in_channels,
+              cubeb_channel_layout in_layout, uint32_t out_channels,
               cubeb_channel_layout out_layout)
-    : _context(format, in_channels, in_layout, out_channels, out_layout)
+      : _context(format, in_channels, in_layout, out_channels, out_layout)
   {
   }
 
-  template<typename T>
-  void copy_and_trunc(size_t frames,
-                      const T * input_buffer,
+  template <typename T>
+  void copy_and_trunc(size_t frames, const T * input_buffer,
                       T * output_buffer) const
   {
     if (_context._in_ch_count <= _context._out_ch_count) {
@@ -545,11 +524,8 @@ struct cubeb_mixer
     }
   }
 
-  int mix(size_t frames,
-          const void * input_buffer,
-          size_t input_buffer_size,
-          void * output_buffer,
-          size_t output_buffer_size) const
+  int mix(size_t frames, const void * input_buffer, size_t input_buffer_size,
+          void * output_buffer, size_t output_buffer_size) const
   {
     if (frames <= 0 || _context._out_ch_count == 0) {
       return 0;
@@ -557,7 +533,7 @@ struct cubeb_mixer
 
     // Check if output buffer is of sufficient size.
     size_t size_read_needed =
-      frames * _context._in_ch_count * cubeb_sample_size(_context._format);
+        frames * _context._in_ch_count * cubeb_sample_size(_context._format);
     if (input_buffer_size < size_read_needed) {
       // We don't have enough data to read!
       return -1;
@@ -571,58 +547,46 @@ struct cubeb_mixer
       // The channel layouts were invalid or unsupported, instead we will simply
       // either drop the extra channels, or fill with silence the missing ones
       if (_context._format == CUBEB_SAMPLE_FLOAT32NE) {
-        copy_and_trunc(frames,
-                       static_cast<const float*>(input_buffer),
-                       static_cast<float*>(output_buffer));
+        copy_and_trunc(frames, static_cast<const float *>(input_buffer),
+                       static_cast<float *>(output_buffer));
       } else {
         assert(_context._format == CUBEB_SAMPLE_S16NE);
-        copy_and_trunc(frames,
-                       static_cast<const int16_t*>(input_buffer),
-                       reinterpret_cast<int16_t*>(output_buffer));
+        copy_and_trunc(frames, static_cast<const int16_t *>(input_buffer),
+                       reinterpret_cast<int16_t *>(output_buffer));
       }
       return 0;
     }
 
-    switch (_context._format)
-    {
-      case CUBEB_SAMPLE_FLOAT32NE: {
-        auto f = [](float x) { return x; };
-        return rematrix(&_context,
-                        static_cast<float*>(output_buffer),
-                        static_cast<const float*>(input_buffer),
-                        _context._matrix_flt,
-                        f,
-                        frames);
+    switch (_context._format) {
+    case CUBEB_SAMPLE_FLOAT32NE: {
+      auto f = [](float x) { return x; };
+      return rematrix(&_context, static_cast<float *>(output_buffer),
+                      static_cast<const float *>(input_buffer),
+                      _context._matrix_flt, f, frames);
+    }
+    case CUBEB_SAMPLE_S16NE:
+      if (_context._clipping) {
+        auto f = [](int x) {
+          int y = (x + 16384) >> 15;
+          // clip the signed integer value into the -32768,32767 range.
+          if ((y + 0x8000U) & ~0xFFFF) {
+            return (y >> 31) ^ 0x7FFF;
+          }
+          return y;
+        };
+        return rematrix(&_context, static_cast<int16_t *>(output_buffer),
+                        static_cast<const int16_t *>(input_buffer),
+                        _context._matrix32, f, frames);
+      } else {
+        auto f = [](int x) { return (x + 16384) >> 15; };
+        return rematrix(&_context, static_cast<int16_t *>(output_buffer),
+                        static_cast<const int16_t *>(input_buffer),
+                        _context._matrix32, f, frames);
       }
-      case CUBEB_SAMPLE_S16NE:
-        if (_context._clipping) {
-          auto f = [](int x) {
-            int y = (x + 16384) >> 15;
-            // clip the signed integer value into the -32768,32767 range.
-            if ((y + 0x8000U) & ~0xFFFF) {
-              return (y >> 31) ^ 0x7FFF;
-            }
-            return y;
-          };
-          return rematrix(&_context,
-                          static_cast<int16_t*>(output_buffer),
-                          static_cast<const int16_t*>(input_buffer),
-                          _context._matrix32,
-                          f,
-                          frames);
-        } else {
-          auto f = [](int x) { return (x + 16384) >> 15; };
-          return rematrix(&_context,
-                          static_cast<int16_t*>(output_buffer),
-                          static_cast<const int16_t*>(input_buffer),
-                          _context._matrix32,
-                          f,
-                          frames);
-        }
-        break;
-      default:
-        assert(false);
-        break;
+      break;
+    default:
+      assert(false);
+      break;
     }
 
     return -1;
@@ -636,28 +600,26 @@ struct cubeb_mixer
   MixerContext _context;
 };
 
-cubeb_mixer* cubeb_mixer_create(cubeb_sample_format format,
-                                uint32_t in_channels,
-                                cubeb_channel_layout in_layout,
-                                uint32_t out_channels,
-                                cubeb_channel_layout out_layout)
+cubeb_mixer *
+cubeb_mixer_create(cubeb_sample_format format, uint32_t in_channels,
+                   cubeb_channel_layout in_layout, uint32_t out_channels,
+                   cubeb_channel_layout out_layout)
 {
-  return new cubeb_mixer(
-    format, in_channels, in_layout, out_channels, out_layout);
+  return new cubeb_mixer(format, in_channels, in_layout, out_channels,
+                         out_layout);
 }
 
-void cubeb_mixer_destroy(cubeb_mixer * mixer)
+void
+cubeb_mixer_destroy(cubeb_mixer * mixer)
 {
   delete mixer;
 }
 
-int cubeb_mixer_mix(cubeb_mixer * mixer,
-                    size_t frames,
-                    const void * input_buffer,
-                    size_t input_buffer_size,
-                    void * output_buffer,
-                    size_t output_buffer_size)
+int
+cubeb_mixer_mix(cubeb_mixer * mixer, size_t frames, const void * input_buffer,
+                size_t input_buffer_size, void * output_buffer,
+                size_t output_buffer_size)
 {
-  return mixer->mix(
-    frames, input_buffer, input_buffer_size, output_buffer, output_buffer_size);
+  return mixer->mix(frames, input_buffer, input_buffer_size, output_buffer,
+                    output_buffer_size);
 }
diff --git a/src/cubeb_mixer.h b/src/cubeb_mixer.h
index d43a237..1859dab 100644
--- a/src/cubeb_mixer.h
+++ b/src/cubeb_mixer.h
@@ -15,20 +15,19 @@ extern "C" {
 #endif
 
 typedef struct cubeb_mixer cubeb_mixer;
-cubeb_mixer * cubeb_mixer_create(cubeb_sample_format format,
-                                 uint32_t in_channels,
-                                 cubeb_channel_layout in_layout,
-                                 uint32_t out_channels,
-                                 cubeb_channel_layout out_layout);
-void cubeb_mixer_destroy(cubeb_mixer * mixer);
-int cubeb_mixer_mix(cubeb_mixer * mixer,
-                    size_t frames,
-                    const void * input_buffer,
-                    size_t input_buffer_size,
-                    void * output_buffer,
-                    size_t output_buffer_size);
+cubeb_mixer *
+cubeb_mixer_create(cubeb_sample_format format, uint32_t in_channels,
+                   cubeb_channel_layout in_layout, uint32_t out_channels,
+                   cubeb_channel_layout out_layout);
+void
+cubeb_mixer_destroy(cubeb_mixer * mixer);
+int
+cubeb_mixer_mix(cubeb_mixer * mixer, size_t frames, const void * input_buffer,
+                size_t input_buffer_size, void * output_buffer,
+                size_t output_buffer_size);
 
-unsigned int cubeb_channel_layout_nb_channels(cubeb_channel_layout channel_layout);
+unsigned int
+cubeb_channel_layout_nb_channels(cubeb_channel_layout channel_layout);
 
 #if defined(__cplusplus)
 }
diff --git a/src/cubeb_opensl.c b/src/cubeb_opensl.c
index 8058ff8..78096d5 100644
--- a/src/cubeb_opensl.c
+++ b/src/cubeb_opensl.c
@@ -5,29 +5,29 @@
  * accompanying file LICENSE for details.
  */
 #undef NDEBUG
+#include <SLES/OpenSLES.h>
 #include <assert.h>
 #include <dlfcn.h>
-#include <stdlib.h>
-#include <pthread.h>
 #include <errno.h>
-#include <SLES/OpenSLES.h>
 #include <math.h>
+#include <pthread.h>
+#include <stdlib.h>
 #include <time.h>
 #if defined(__ANDROID__)
-#include <dlfcn.h>
-#include <sys/system_properties.h>
 #include "android/sles_definitions.h"
 #include <SLES/OpenSLES_Android.h>
-#include <android/log.h>
 #include <android/api-level.h>
+#include <android/log.h>
+#include <dlfcn.h>
+#include <sys/system_properties.h>
 #endif
-#include "cubeb/cubeb.h"
+#include "android/cubeb-output-latency.h"
 #include "cubeb-internal.h"
-#include "cubeb_resampler.h"
 #include "cubeb-sles.h"
-#include "cubeb_array_queue.h"
-#include "android/cubeb-output-latency.h"
+#include "cubeb/cubeb.h"
 #include "cubeb_android.h"
+#include "cubeb_array_queue.h"
+#include "cubeb_resampler.h"
 
 #if defined(__ANDROID__)
 #ifdef LOG
@@ -35,24 +35,32 @@
 #endif
 //#define LOGGING_ENABLED
 #ifdef LOGGING_ENABLED
-#define LOG(args...)  __android_log_print(ANDROID_LOG_INFO, "Cubeb_OpenSL" , ## args)
+#define LOG(args...)                                                           \
+  __android_log_print(ANDROID_LOG_INFO, "Cubeb_OpenSL", ##args)
 #else
 #define LOG(...)
 #endif
 
 //#define TIMESTAMP_ENABLED
 #ifdef TIMESTAMP_ENABLED
-#define FILENAME (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
-#define LOG_TS(args...)  __android_log_print(ANDROID_LOG_INFO, "Cubeb_OpenSL ES: Timestamp(usec)" , ## args)
-#define TIMESTAMP(msg) do {                           \
-  struct timeval timestamp;                           \
-  int ts_ret = gettimeofday(&timestamp, NULL);        \
-  if (ts_ret == 0) {                                  \
-    LOG_TS("%lld: %s (%s %s:%d)", timestamp.tv_sec * 1000000LL + timestamp.tv_usec, msg, __FUNCTION__, FILENAME, __LINE__);\
-  } else {                                            \
-    LOG_TS("Error: %s (%s %s:%d) - %s", msg, __FUNCTION__, FILENAME, __LINE__);\
-  }                                                   \
-} while(0)
+#define FILENAME                                                               \
+  (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
+#define LOG_TS(args...)                                                        \
+  __android_log_print(ANDROID_LOG_INFO, "Cubeb_OpenSL ES: Timestamp(usec)",    \
+                      ##args)
+#define TIMESTAMP(msg)                                                         \
+  do {                                                                         \
+    struct timeval timestamp;                                                  \
+    int ts_ret = gettimeofday(&timestamp, NULL);                               \
+    if (ts_ret == 0) {                                                         \
+      LOG_TS("%lld: %s (%s %s:%d)",                                            \
+             timestamp.tv_sec * 1000000LL + timestamp.tv_usec, msg,            \
+             __FUNCTION__, FILENAME, __LINE__);                                \
+    } else {                                                                   \
+      LOG_TS("Error: %s (%s %s:%d) - %s", msg, __FUNCTION__, FILENAME,         \
+             __LINE__);                                                        \
+    }                                                                          \
+  } while (0)
 #else
 #define TIMESTAMP(...)
 #endif
@@ -169,15 +177,18 @@ struct cubeb_stream {
 };
 
 /* Forward declaration. */
-static int opensl_stop_player(cubeb_stream * stm);
-static int opensl_stop_recorder(cubeb_stream * stm);
+static int
+opensl_stop_player(cubeb_stream * stm);
+static int
+opensl_stop_recorder(cubeb_stream * stm);
 
 static int
 opensl_get_draining(cubeb_stream * stm)
 {
 #ifdef DEBUG
   int r = pthread_mutex_trylock(&stm->mutex);
-  assert((r == EDEADLK || r == EBUSY) && "get_draining: mutex should be locked but it's not.");
+  assert((r == EDEADLK || r == EBUSY) &&
+         "get_draining: mutex should be locked but it's not.");
 #endif
   return stm->draining;
 }
@@ -188,7 +199,8 @@ opensl_set_draining(cubeb_stream * stm, int value)
 #ifdef DEBUG
   int r = pthread_mutex_trylock(&stm->mutex);
   LOG("set draining try r = %d", r);
-  assert((r == EDEADLK || r == EBUSY) && "set_draining: mutex should be locked but it's not.");
+  assert((r == EDEADLK || r == EBUSY) &&
+         "set_draining: mutex should be locked but it's not.");
 #endif
   assert(value == 0 || value == 1);
   stm->draining = value;
@@ -222,7 +234,8 @@ opensl_get_shutdown(cubeb_stream * stm)
 {
 #ifdef DEBUG
   int r = pthread_mutex_trylock(&stm->mutex);
-  assert((r == EDEADLK || r == EBUSY) && "get_shutdown: mutex should be locked but it's not.");
+  assert((r == EDEADLK || r == EBUSY) &&
+         "get_shutdown: mutex should be locked but it's not.");
 #endif
   return stm->shutdown;
 }
@@ -233,7 +246,8 @@ opensl_set_shutdown(cubeb_stream * stm, uint32_t value)
 #ifdef DEBUG
   int r = pthread_mutex_trylock(&stm->mutex);
   LOG("set shutdown try r = %d", r);
-  assert((r == EDEADLK || r == EBUSY) && "set_shutdown: mutex should be locked but it's not.");
+  assert((r == EDEADLK || r == EBUSY) &&
+         "set_shutdown: mutex should be locked but it's not.");
 #endif
   assert(value == 0 || value == 1);
   stm->shutdown = value;
@@ -245,8 +259,8 @@ play_callback(SLPlayItf caller, void * user_ptr, SLuint32 event)
   cubeb_stream * stm = user_ptr;
   assert(stm);
   switch (event) {
-    case SL_PLAYEVENT_HEADATMARKER:
-      opensl_notify_drained(stm);
+  case SL_PLAYEVENT_HEADATMARKER:
+    opensl_notify_drained(stm);
     break;
   default:
     break;
@@ -254,7 +268,7 @@ play_callback(SLPlayItf caller, void * user_ptr, SLuint32 event)
 }
 
 static void
-recorder_marker_callback (SLRecordItf caller, void * pContext, SLuint32 event)
+recorder_marker_callback(SLRecordItf caller, void * pContext, SLuint32 event)
 {
   cubeb_stream * stm = pContext;
   assert(stm);
@@ -295,7 +309,7 @@ bufferqueue_callback(SLBufferQueueItf caller, void * user_ptr)
     return;
   }
 
-  uint8_t *buf = stm->queuebuf[stm->queuebuf_idx];
+  uint8_t * buf = stm->queuebuf[stm->queuebuf_idx];
   written = 0;
   int r = pthread_mutex_lock(&stm->mutex);
   assert(r == 0);
@@ -304,9 +318,8 @@ bufferqueue_callback(SLBufferQueueItf caller, void * user_ptr)
   r = pthread_mutex_unlock(&stm->mutex);
   assert(r == 0);
   if (!draining && !shutdown) {
-    written = cubeb_resampler_fill(stm->resampler,
-                                   NULL, NULL,
-                                   buf, stm->queuebuf_len / stm->framesize);
+    written = cubeb_resampler_fill(stm->resampler, NULL, NULL, buf,
+                                   stm->queuebuf_len / stm->framesize);
     LOG("bufferqueue_callback: resampler fill returned %ld frames", written);
     if (written < 0 || written * stm->framesize > stm->queuebuf_len) {
       r = pthread_mutex_lock(&stm->mutex);
@@ -323,7 +336,8 @@ bufferqueue_callback(SLBufferQueueItf caller, void * user_ptr)
   // Keep sending silent data even in draining mode to prevent the audio
   // back-end from being stopped automatically by OpenSL/ES.
   assert(stm->queuebuf_len >= written * stm->framesize);
-  memset(buf + written * stm->framesize, 0, stm->queuebuf_len - written * stm->framesize);
+  memset(buf + written * stm->framesize, 0,
+         stm->queuebuf_len - written * stm->framesize);
   res = (*stm->bufq)->Enqueue(stm->bufq, buf, stm->queuebuf_len);
   assert(res == SL_RESULT_SUCCESS);
   stm->queuebuf_idx = (stm->queuebuf_idx + 1) % stm->queuebuf_capacity;
@@ -338,7 +352,8 @@ bufferqueue_callback(SLBufferQueueItf caller, void * user_ptr)
     LOG("bufferqueue_callback draining");
     r = pthread_mutex_lock(&stm->mutex);
     assert(r == 0);
-    int64_t written_duration = INT64_C(1000) * stm->written * stm->framesize / stm->bytespersec;
+    int64_t written_duration =
+        INT64_C(1000) * stm->written * stm->framesize / stm->bytespersec;
     opensl_set_draining(stm, 1);
     r = pthread_mutex_unlock(&stm->mutex);
     assert(r == 0);
@@ -350,7 +365,8 @@ bufferqueue_callback(SLBufferQueueItf caller, void * user_ptr)
     } else {
       // Use SL_PLAYEVENT_HEADATMARKER event from slPlayCallback of SLPlayItf
       // to make sure all the data has been processed.
-      (*stm->play)->SetMarkerPosition(stm->play, (SLmillisecond)written_duration);
+      (*stm->play)
+          ->SetMarkerPosition(stm->play, (SLmillisecond)written_duration);
     }
     return;
   }
@@ -368,16 +384,18 @@ opensl_enqueue_recorder(cubeb_stream * stm, void ** last_filled_buffer)
     // This is the first enqueue
     current_index = 0;
   } else {
-    // The current index hold the last filled buffer get it before advance index.
+    // The current index hold the last filled buffer get it before advance
+    // index.
     last_buffer = stm->input_buffer_array[current_index];
     // Advance to get next available buffer
     current_index = (current_index + 1) % stm->input_array_capacity;
   }
   // enqueue next empty buffer to be filled by the recorder
-  SLresult res = (*stm->recorderBufferQueueItf)->Enqueue(stm->recorderBufferQueueItf,
-                                                         stm->input_buffer_array[current_index],
-                                                         stm->input_buffer_length);
-  if (res != SL_RESULT_SUCCESS ) {
+  SLresult res = (*stm->recorderBufferQueueItf)
+                     ->Enqueue(stm->recorderBufferQueueItf,
+                               stm->input_buffer_array[current_index],
+                               stm->input_buffer_length);
+  if (res != SL_RESULT_SUCCESS) {
     LOG("Enqueue recorder failed. Error code: %lu", res);
     return CUBEB_ERROR;
   }
@@ -390,7 +408,8 @@ opensl_enqueue_recorder(cubeb_stream * stm, void ** last_filled_buffer)
 }
 
 // input data callback
-void recorder_callback(SLAndroidSimpleBufferQueueItf bq, void * context)
+void
+recorder_callback(SLAndroidSimpleBufferQueueItf bq, void * context)
 {
   assert(context);
   cubeb_stream * stm = context;
@@ -420,11 +439,8 @@ void recorder_callback(SLAndroidSimpleBufferQueueItf bq, void * context)
   assert(input_buffer);
   // Fill resampler with last input
   long input_frame_count = stm->input_buffer_length / stm->input_frame_size;
-  long got = cubeb_resampler_fill(stm->resampler,
-                                  input_buffer,
-                                  &input_frame_count,
-                                  NULL,
-                                  0);
+  long got = cubeb_resampler_fill(stm->resampler, input_buffer,
+                                  &input_frame_count, NULL, 0);
   // Error case
   if (got < 0 || got > input_frame_count) {
     r = pthread_mutex_lock(&stm->mutex);
@@ -446,13 +462,16 @@ void recorder_callback(SLAndroidSimpleBufferQueueItf bq, void * context)
     opensl_set_draining(stm, 1);
     r = pthread_mutex_unlock(&stm->mutex);
     assert(r == 0);
-    int64_t duration = INT64_C(1000) * stm->input_total_frames / stm->input_device_rate;
-    (*stm->recorderItf)->SetMarkerPosition(stm->recorderItf, (SLmillisecond)duration);
+    int64_t duration =
+        INT64_C(1000) * stm->input_total_frames / stm->input_device_rate;
+    (*stm->recorderItf)
+        ->SetMarkerPosition(stm->recorderItf, (SLmillisecond)duration);
     return;
   }
 }
 
-void recorder_fullduplex_callback(SLAndroidSimpleBufferQueueItf bq, void * context)
+void
+recorder_fullduplex_callback(SLAndroidSimpleBufferQueueItf bq, void * context)
 {
   assert(context);
   cubeb_stream * stm = context;
@@ -467,10 +486,10 @@ void recorder_fullduplex_callback(SLAndroidSimpleBufferQueueItf bq, void * conte
 
   if (shutdown || draining) {
     /* On draining and shutdown the recorder should have been stoped from
-    *  the one set the flags. Accordint to the doc, on transition to
-    *  the SL_RECORDSTATE_STOPPED state, the application should
-    *  continue to enqueue buffers onto the queue to retrieve the residual
-    *  recorded data in the system. */
+     *  the one set the flags. Accordint to the doc, on transition to
+     *  the SL_RECORDSTATE_STOPPED state, the application should
+     *  continue to enqueue buffers onto the queue to retrieve the residual
+     *  recorded data in the system. */
     LOG("Input shutdown %d or drain %d", shutdown, draining);
     int r = opensl_enqueue_recorder(stm, NULL);
     assert(r == CUBEB_OK);
@@ -525,9 +544,7 @@ player_fullduplex_callback(SLBufferQueueItf caller, void * user_ptr)
     memset(output_buffer, 0, stm->queuebuf_len);
 
     // Enqueue data in player buffer queue
-    res = (*stm->bufq)->Enqueue(stm->bufq,
-                                output_buffer,
-                                stm->queuebuf_len);
+    res = (*stm->bufq)->Enqueue(stm->bufq, output_buffer, stm->queuebuf_len);
     assert(res == SL_RESULT_SUCCESS);
     return;
   }
@@ -543,16 +560,14 @@ player_fullduplex_callback(SLBufferQueueItf caller, void * user_ptr)
 
   long written = 0;
   // Trigger user callback through resampler
-  written = cubeb_resampler_fill(stm->resampler,
-                                 input_buffer,
-                                 &input_frame_count,
-                                 output_buffer,
-                                 frames_needed);
+  written =
+      cubeb_resampler_fill(stm->resampler, input_buffer, &input_frame_count,
+                           output_buffer, frames_needed);
 
-  LOG("Fill: written %ld, frames_needed %ld, input array size %zu",
-      written, frames_needed, array_queue_get_size(stm->input_queue));
+  LOG("Fill: written %ld, frames_needed %ld, input array size %zu", written,
+      frames_needed, array_queue_get_size(stm->input_queue));
 
-  if (written < 0 || written  > frames_needed) {
+  if (written < 0 || written > frames_needed) {
     // Error case
     r = pthread_mutex_lock(&stm->mutex);
     assert(r == 0);
@@ -565,9 +580,7 @@ player_fullduplex_callback(SLBufferQueueItf caller, void * user_ptr)
     memset(output_buffer, 0, stm->queuebuf_len);
 
     // Enqueue data in player buffer queue
-    res = (*stm->bufq)->Enqueue(stm->bufq,
-                                output_buffer,
-                                stm->queuebuf_len);
+    res = (*stm->bufq)->Enqueue(stm->bufq, output_buffer, stm->queuebuf_len);
     assert(res == SL_RESULT_SUCCESS);
     return;
   }
@@ -579,10 +592,11 @@ player_fullduplex_callback(SLBufferQueueItf caller, void * user_ptr)
   r = pthread_mutex_unlock(&stm->mutex);
   assert(r == 0);
 
-  if ( written < frames_needed) {
+  if (written < frames_needed) {
     r = pthread_mutex_lock(&stm->mutex);
     assert(r == 0);
-    int64_t written_duration = INT64_C(1000) * stm->written * stm->framesize / stm->bytespersec;
+    int64_t written_duration =
+        INT64_C(1000) * stm->written * stm->framesize / stm->bytespersec;
     opensl_set_draining(stm, 1);
     r = pthread_mutex_unlock(&stm->mutex);
     assert(r == 0);
@@ -598,29 +612,28 @@ player_fullduplex_callback(SLBufferQueueItf caller, void * user_ptr)
          stm->queuebuf_len - written * stm->framesize);
 
   // Enqueue data in player buffer queue
-  res = (*stm->bufq)->Enqueue(stm->bufq,
-                              output_buffer,
-                              stm->queuebuf_len);
+  res = (*stm->bufq)->Enqueue(stm->bufq, output_buffer, stm->queuebuf_len);
   assert(res == SL_RESULT_SUCCESS);
   TIMESTAMP("EXIT");
 }
 
-static void opensl_destroy(cubeb * ctx);
+static void
+opensl_destroy(cubeb * ctx);
 
 #if defined(__ANDROID__)
 #if (__ANDROID_API__ >= ANDROID_VERSION_LOLLIPOP)
-typedef int (system_property_get)(const char*, char*);
+typedef int(system_property_get)(const char *, char *);
 
 static int
-wrap_system_property_get(const char* name, char* value)
+wrap_system_property_get(const char * name, char * value)
 {
-  void* libc = dlopen("libc.so", RTLD_LAZY);
+  void * libc = dlopen("libc.so", RTLD_LAZY);
   if (!libc) {
     LOG("Failed to open libc.so");
     return -1;
   }
-  system_property_get* func = (system_property_get*)
-                              dlsym(libc, "__system_property_get");
+  system_property_get * func =
+      (system_property_get *)dlsym(libc, "__system_property_get");
   int ret = -1;
   if (func) {
     ret = func(name, value);
@@ -660,7 +673,8 @@ opensl_init(cubeb ** context, char const * context_name)
 
 #if defined(__ANDROID__)
   int android_version = get_android_version();
-  if (android_version > 0 && android_version <= ANDROID_VERSION_GINGERBREAD_MR1) {
+  if (android_version > 0 &&
+      android_version <= ANDROID_VERSION_GINGERBREAD_MR1) {
     // Don't even attempt to run on Gingerbread and lower
     return CUBEB_ERROR;
   }
@@ -679,35 +693,34 @@ opensl_init(cubeb ** context, char const * context_name)
     return CUBEB_ERROR;
   }
 
-  typedef SLresult (*slCreateEngine_t)(SLObjectItf *,
-                                       SLuint32,
-                                       const SLEngineOption *,
-                                       SLuint32,
-                                       const SLInterfaceID *,
-                                       const SLboolean *);
+  typedef SLresult (*slCreateEngine_t)(
+      SLObjectItf *, SLuint32, const SLEngineOption *, SLuint32,
+      const SLInterfaceID *, const SLboolean *);
   slCreateEngine_t f_slCreateEngine =
-    (slCreateEngine_t)dlsym(ctx->lib, "slCreateEngine");
-  SLInterfaceID SL_IID_ENGINE = *(SLInterfaceID *)dlsym(ctx->lib, "SL_IID_ENGINE");
-  SLInterfaceID SL_IID_OUTPUTMIX = *(SLInterfaceID *)dlsym(ctx->lib, "SL_IID_OUTPUTMIX");
+      (slCreateEngine_t)dlsym(ctx->lib, "slCreateEngine");
+  SLInterfaceID SL_IID_ENGINE =
+      *(SLInterfaceID *)dlsym(ctx->lib, "SL_IID_ENGINE");
+  SLInterfaceID SL_IID_OUTPUTMIX =
+      *(SLInterfaceID *)dlsym(ctx->lib, "SL_IID_OUTPUTMIX");
   ctx->SL_IID_VOLUME = *(SLInterfaceID *)dlsym(ctx->lib, "SL_IID_VOLUME");
-  ctx->SL_IID_BUFFERQUEUE = *(SLInterfaceID *)dlsym(ctx->lib, "SL_IID_BUFFERQUEUE");
+  ctx->SL_IID_BUFFERQUEUE =
+      *(SLInterfaceID *)dlsym(ctx->lib, "SL_IID_BUFFERQUEUE");
 #if defined(__ANDROID__)
-  ctx->SL_IID_ANDROIDCONFIGURATION = *(SLInterfaceID *)dlsym(ctx->lib, "SL_IID_ANDROIDCONFIGURATION");
-  ctx->SL_IID_ANDROIDSIMPLEBUFFERQUEUE = *(SLInterfaceID *)dlsym(ctx->lib, "SL_IID_ANDROIDSIMPLEBUFFERQUEUE");
+  ctx->SL_IID_ANDROIDCONFIGURATION =
+      *(SLInterfaceID *)dlsym(ctx->lib, "SL_IID_ANDROIDCONFIGURATION");
+  ctx->SL_IID_ANDROIDSIMPLEBUFFERQUEUE =
+      *(SLInterfaceID *)dlsym(ctx->lib, "SL_IID_ANDROIDSIMPLEBUFFERQUEUE");
 #endif
   ctx->SL_IID_PLAY = *(SLInterfaceID *)dlsym(ctx->lib, "SL_IID_PLAY");
   ctx->SL_IID_RECORD = *(SLInterfaceID *)dlsym(ctx->lib, "SL_IID_RECORD");
 
-  if (!f_slCreateEngine ||
-      !SL_IID_ENGINE ||
-      !SL_IID_OUTPUTMIX ||
+  if (!f_slCreateEngine || !SL_IID_ENGINE || !SL_IID_OUTPUTMIX ||
       !ctx->SL_IID_BUFFERQUEUE ||
 #if defined(__ANDROID__)
       !ctx->SL_IID_ANDROIDCONFIGURATION ||
       !ctx->SL_IID_ANDROIDSIMPLEBUFFERQUEUE ||
 #endif
-      !ctx->SL_IID_PLAY ||
-      !ctx->SL_IID_RECORD) {
+      !ctx->SL_IID_PLAY || !ctx->SL_IID_RECORD) {
     opensl_destroy(ctx);
     return CUBEB_ERROR;
   }
@@ -736,7 +749,8 @@ opensl_init(cubeb ** context, char const * context_name)
 
   const SLInterfaceID idsom[] = {SL_IID_OUTPUTMIX};
   const SLboolean reqom[] = {SL_BOOLEAN_TRUE};
-  res = (*ctx->eng)->CreateOutputMix(ctx->eng, &ctx->outmixObj, 1, idsom, reqom);
+  res =
+      (*ctx->eng)->CreateOutputMix(ctx->eng, &ctx->outmixObj, 1, idsom, reqom);
   if (res != SL_RESULT_SUCCESS) {
     opensl_destroy(ctx);
     return CUBEB_ERROR;
@@ -748,9 +762,11 @@ opensl_init(cubeb ** context, char const * context_name)
     return CUBEB_ERROR;
   }
 
-  ctx->p_output_latency_function = cubeb_output_latency_load_method(android_version);
+  ctx->p_output_latency_function =
+      cubeb_output_latency_load_method(android_version);
   if (!cubeb_output_latency_method_is_loaded(ctx->p_output_latency_function)) {
-    LOG("Warning: output latency is not available, cubeb_stream_get_position() is not supported");
+    LOG("Warning: output latency is not available, cubeb_stream_get_position() "
+        "is not supported");
   }
 
   *context = ctx;
@@ -770,7 +786,8 @@ opensl_get_max_channel_count(cubeb * ctx, uint32_t * max_channels)
 {
   assert(ctx && max_channels);
   /* The android mixer handles up to two channels, see
-     http://androidxref.com/4.2.2_r1/xref/frameworks/av/services/audioflinger/AudioFlinger.h#67 */
+     http://androidxref.com/4.2.2_r1/xref/frameworks/av/services/audioflinger/AudioFlinger.h#67
+   */
   *max_channels = 2;
 
   return CUBEB_OK;
@@ -789,11 +806,13 @@ opensl_destroy(cubeb * ctx)
   free(ctx);
 }
 
-static void opensl_stream_destroy(cubeb_stream * stm);
+static void
+opensl_stream_destroy(cubeb_stream * stm);
 
 #if defined(__ANDROID__) && (__ANDROID_API__ >= ANDROID_VERSION_LOLLIPOP)
 static int
-opensl_set_format_ext(SLAndroidDataFormat_PCM_EX * format, cubeb_stream_params * params)
+opensl_set_format_ext(SLAndroidDataFormat_PCM_EX * format,
+                      cubeb_stream_params * params)
 {
   assert(format);
   assert(params);
@@ -802,37 +821,37 @@ opensl_set_format_ext(SLAndroidDataFormat_PCM_EX * format, cubeb_stream_params *
   format->numChannels = params->channels;
   // sampleRate is in milliHertz
   format->sampleRate = params->rate * 1000;
-  format->channelMask = params->channels == 1 ?
-                       SL_SPEAKER_FRONT_CENTER :
-                       SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT;
+  format->channelMask = params->channels == 1
+                            ? SL_SPEAKER_FRONT_CENTER
+                            : SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT;
 
   switch (params->format) {
-    case CUBEB_SAMPLE_S16LE:
-      format->bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_16;
-      format->containerSize = SL_PCMSAMPLEFORMAT_FIXED_16;
-      format->representation = SL_ANDROID_PCM_REPRESENTATION_SIGNED_INT;
-      format->endianness = SL_BYTEORDER_LITTLEENDIAN;
-      break;
-    case CUBEB_SAMPLE_S16BE:
-      format->bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_16;
-      format->containerSize = SL_PCMSAMPLEFORMAT_FIXED_16;
-      format->representation = SL_ANDROID_PCM_REPRESENTATION_SIGNED_INT;
-      format->endianness = SL_BYTEORDER_BIGENDIAN;
-      break;
-    case CUBEB_SAMPLE_FLOAT32LE:
-      format->bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_32;
-      format->containerSize = SL_PCMSAMPLEFORMAT_FIXED_32;
-      format->representation = SL_ANDROID_PCM_REPRESENTATION_FLOAT;
-      format->endianness = SL_BYTEORDER_LITTLEENDIAN;
-      break;
-    case CUBEB_SAMPLE_FLOAT32BE:
-      format->bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_32;
-      format->containerSize = SL_PCMSAMPLEFORMAT_FIXED_32;
-      format->representation = SL_ANDROID_PCM_REPRESENTATION_FLOAT;
-      format->endianness = SL_BYTEORDER_BIGENDIAN;
-      break;
-    default:
-      return CUBEB_ERROR_INVALID_FORMAT;
+  case CUBEB_SAMPLE_S16LE:
+    format->bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_16;
+    format->containerSize = SL_PCMSAMPLEFORMAT_FIXED_16;
+    format->representation = SL_ANDROID_PCM_REPRESENTATION_SIGNED_INT;
+    format->endianness = SL_BYTEORDER_LITTLEENDIAN;
+    break;
+  case CUBEB_SAMPLE_S16BE:
+    format->bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_16;
+    format->containerSize = SL_PCMSAMPLEFORMAT_FIXED_16;
+    format->representation = SL_ANDROID_PCM_REPRESENTATION_SIGNED_INT;
+    format->endianness = SL_BYTEORDER_BIGENDIAN;
+    break;
+  case CUBEB_SAMPLE_FLOAT32LE:
+    format->bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_32;
+    format->containerSize = SL_PCMSAMPLEFORMAT_FIXED_32;
+    format->representation = SL_ANDROID_PCM_REPRESENTATION_FLOAT;
+    format->endianness = SL_BYTEORDER_LITTLEENDIAN;
+    break;
+  case CUBEB_SAMPLE_FLOAT32BE:
+    format->bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_32;
+    format->containerSize = SL_PCMSAMPLEFORMAT_FIXED_32;
+    format->representation = SL_ANDROID_PCM_REPRESENTATION_FLOAT;
+    format->endianness = SL_BYTEORDER_BIGENDIAN;
+    break;
+  default:
+    return CUBEB_ERROR_INVALID_FORMAT;
   }
   return CUBEB_OK;
 }
@@ -850,19 +869,19 @@ opensl_set_format(SLDataFormat_PCM * format, cubeb_stream_params * params)
   format->samplesPerSec = params->rate * 1000;
   format->bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_16;
   format->containerSize = SL_PCMSAMPLEFORMAT_FIXED_16;
-  format->channelMask = params->channels == 1 ?
-                       SL_SPEAKER_FRONT_CENTER :
-                       SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT;
+  format->channelMask = params->channels == 1
+                            ? SL_SPEAKER_FRONT_CENTER
+                            : SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT;
 
   switch (params->format) {
-    case CUBEB_SAMPLE_S16LE:
-      format->endianness = SL_BYTEORDER_LITTLEENDIAN;
-          break;
-    case CUBEB_SAMPLE_S16BE:
-      format->endianness = SL_BYTEORDER_BIGENDIAN;
-          break;
-    default:
-      return CUBEB_ERROR_INVALID_FORMAT;
+  case CUBEB_SAMPLE_S16LE:
+    format->endianness = SL_BYTEORDER_LITTLEENDIAN;
+    break;
+  case CUBEB_SAMPLE_S16BE:
+    format->endianness = SL_BYTEORDER_BIGENDIAN;
+    break;
+  default:
+    return CUBEB_ERROR_INVALID_FORMAT;
   }
   return CUBEB_OK;
 }
@@ -900,38 +919,36 @@ opensl_configure_capture(cubeb_stream * stm, cubeb_stream_params * params)
   lDataSource.pLocator = &lDataLocatorIn;
   lDataSource.pFormat = NULL;
 
-  const SLInterfaceID lSoundRecorderIIDs[] = { stm->context->SL_IID_RECORD,
-                                               stm->context->SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
-                                               stm->context->SL_IID_ANDROIDCONFIGURATION };
+  const SLInterfaceID lSoundRecorderIIDs[] = {
+      stm->context->SL_IID_RECORD,
+      stm->context->SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
+      stm->context->SL_IID_ANDROIDCONFIGURATION};
 
-  const SLboolean lSoundRecorderReqs[] = { SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE };
+  const SLboolean lSoundRecorderReqs[] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE,
+                                          SL_BOOLEAN_TRUE};
   // create the audio recorder abstract object
-  SLresult res = (*stm->context->eng)->CreateAudioRecorder(stm->context->eng,
-                                                           &stm->recorderObj,
-                                                           &lDataSource,
-                                                           &lDataSink,
-                                                           NELEMS(lSoundRecorderIIDs),
-                                                           lSoundRecorderIIDs,
-                                                           lSoundRecorderReqs);
+  SLresult res = (*stm->context->eng)
+                     ->CreateAudioRecorder(
+                         stm->context->eng, &stm->recorderObj, &lDataSource,
+                         &lDataSink, NELEMS(lSoundRecorderIIDs),
+                         lSoundRecorderIIDs, lSoundRecorderReqs);
   // Sample rate not supported. Try again with default sample rate!
   if (res == SL_RESULT_CONTENT_UNSUPPORTED) {
     if (stm->output_enabled && stm->output_configured_rate != 0) {
       // Set the same with the player. Since there is no
       // api for input device this is a safe choice.
       stm->input_device_rate = stm->output_configured_rate;
-    } else  {
+    } else {
       // The output preferred rate is used for an input only scenario.
       // The default rate expected to be supported from all android devices.
       stm->input_device_rate = DEFAULT_SAMPLE_RATE;
     }
     lDataFormat.samplesPerSec = stm->input_device_rate * 1000;
-    res = (*stm->context->eng)->CreateAudioRecorder(stm->context->eng,
-                                                    &stm->recorderObj,
-                                                    &lDataSource,
-                                                    &lDataSink,
-                                                    NELEMS(lSoundRecorderIIDs),
-                                                    lSoundRecorderIIDs,
-                                                    lSoundRecorderReqs);
+    res = (*stm->context->eng)
+              ->CreateAudioRecorder(stm->context->eng, &stm->recorderObj,
+                                    &lDataSource, &lDataSink,
+                                    NELEMS(lSoundRecorderIIDs),
+                                    lSoundRecorderIIDs, lSoundRecorderReqs);
 
     if (res != SL_RESULT_SUCCESS) {
       LOG("Failed to create recorder. Error code: %lu", res);
@@ -939,7 +956,6 @@ opensl_configure_capture(cubeb_stream * stm, cubeb_stream_params * params)
     }
   }
 
-
   if (get_android_version() > ANDROID_VERSION_JELLY_BEAN) {
     SLAndroidConfigurationItf recorderConfig;
     res = (*stm->recorderObj)
@@ -948,7 +964,8 @@ opensl_configure_capture(cubeb_stream * stm, cubeb_stream_params * params)
                              &recorderConfig);
 
     if (res != SL_RESULT_SUCCESS) {
-      LOG("Failed to get the android configuration interface for recorder. Error "
+      LOG("Failed to get the android configuration interface for recorder. "
+          "Error "
           "code: %lu",
           res);
       return CUBEB_ERROR;
@@ -956,16 +973,19 @@ opensl_configure_capture(cubeb_stream * stm, cubeb_stream_params * params)
 
     // Voice recognition is the lowest latency, according to the docs. Camcorder
     // uses a microphone that is in the same direction as the camera.
-    SLint32 streamType = stm->voice_input ? SL_ANDROID_RECORDING_PRESET_VOICE_RECOGNITION
-                                          : SL_ANDROID_RECORDING_PRESET_CAMCORDER;
+    SLint32 streamType = stm->voice_input
+                             ? SL_ANDROID_RECORDING_PRESET_VOICE_RECOGNITION
+                             : SL_ANDROID_RECORDING_PRESET_CAMCORDER;
 
-    res = (*recorderConfig)
-              ->SetConfiguration(recorderConfig, SL_ANDROID_KEY_RECORDING_PRESET,
-                                 &streamType, sizeof(SLint32));
+    res =
+        (*recorderConfig)
+            ->SetConfiguration(recorderConfig, SL_ANDROID_KEY_RECORDING_PRESET,
+                               &streamType, sizeof(SLint32));
 
     if (res != SL_RESULT_SUCCESS) {
       LOG("Failed to set the android configuration to VOICE for the recorder. "
-          "Error code: %lu", res);
+          "Error code: %lu",
+          res);
       return CUBEB_ERROR;
     }
   }
@@ -976,15 +996,16 @@ opensl_configure_capture(cubeb_stream * stm, cubeb_stream_params * params)
     return CUBEB_ERROR;
   }
   // get the record interface
-  res = (*stm->recorderObj)->GetInterface(stm->recorderObj,
-                                          stm->context->SL_IID_RECORD,
-                                          &stm->recorderItf);
+  res = (*stm->recorderObj)
+            ->GetInterface(stm->recorderObj, stm->context->SL_IID_RECORD,
+                           &stm->recorderItf);
   if (res != SL_RESULT_SUCCESS) {
     LOG("Failed to get recorder interface. Error code: %lu", res);
     return CUBEB_ERROR;
   }
 
-  res = (*stm->recorderItf)->RegisterCallback(stm->recorderItf, recorder_marker_callback, stm);
+  res = (*stm->recorderItf)
+            ->RegisterCallback(stm->recorderItf, recorder_marker_callback, stm);
   if (res != SL_RESULT_SUCCESS) {
     LOG("Failed to register recorder marker callback. Error code: %lu", res);
     return CUBEB_ERROR;
@@ -992,17 +1013,22 @@ opensl_configure_capture(cubeb_stream * stm, cubeb_stream_params * params)
 
   (*stm->recorderItf)->SetMarkerPosition(stm->recorderItf, (SLmillisecond)0);
 
-  res = (*stm->recorderItf)->SetCallbackEventsMask(stm->recorderItf, (SLuint32)SL_RECORDEVENT_HEADATMARKER);
+  res = (*stm->recorderItf)
+            ->SetCallbackEventsMask(stm->recorderItf,
+                                    (SLuint32)SL_RECORDEVENT_HEADATMARKER);
   if (res != SL_RESULT_SUCCESS) {
     LOG("Failed to set headatmarker event mask. Error code: %lu", res);
     return CUBEB_ERROR;
   }
   // get the simple android buffer queue interface
-  res = (*stm->recorderObj)->GetInterface(stm->recorderObj,
-                                          stm->context->SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
-                                          &stm->recorderBufferQueueItf);
+  res = (*stm->recorderObj)
+            ->GetInterface(stm->recorderObj,
+                           stm->context->SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
+                           &stm->recorderBufferQueueItf);
   if (res != SL_RESULT_SUCCESS) {
-    LOG("Failed to get recorder (android) buffer queue interface. Error code: %lu", res);
+    LOG("Failed to get recorder (android) buffer queue interface. Error code: "
+        "%lu",
+        res);
     return CUBEB_ERROR;
   }
 
@@ -1012,11 +1038,11 @@ opensl_configure_capture(cubeb_stream * stm, cubeb_stream_params * params)
     // Register full duplex callback instead.
     rec_callback = recorder_fullduplex_callback;
   }
-  res = (*stm->recorderBufferQueueItf)->RegisterCallback(stm->recorderBufferQueueItf,
-                                                         rec_callback,
-                                                         stm);
+  res = (*stm->recorderBufferQueueItf)
+            ->RegisterCallback(stm->recorderBufferQueueItf, rec_callback, stm);
   if (res != SL_RESULT_SUCCESS) {
-    LOG("Failed to register recorder buffer queue callback. Error code: %lu", res);
+    LOG("Failed to register recorder buffer queue callback. Error code: %lu",
+        res);
     return CUBEB_ERROR;
   }
 
@@ -1028,14 +1054,16 @@ opensl_configure_capture(cubeb_stream * stm, cubeb_stream_params * params)
   stm->input_array_capacity = NBUFS;
   if (stm->output_enabled) {
     // Full duplex, update capacity to hold 1 sec of data
-    stm->input_array_capacity = 1 * stm->input_device_rate / stm->input_buffer_length;
+    stm->input_array_capacity =
+        1 * stm->input_device_rate / stm->input_buffer_length;
   }
   // Allocate input array
-  stm->input_buffer_array = (void**)calloc(1, sizeof(void*)*stm->input_array_capacity);
+  stm->input_buffer_array =
+      (void **)calloc(1, sizeof(void *) * stm->input_array_capacity);
   // Buffering has not started yet.
   stm->input_buffer_index = -1;
   // Prepare input buffers
-  for(uint32_t i = 0; i < stm->input_array_capacity; ++i) {
+  for (uint32_t i = 0; i < stm->input_array_capacity; ++i) {
     stm->input_buffer_array[i] = calloc(1, stm->input_buffer_length);
   }
 
@@ -1059,22 +1087,25 @@ opensl_configure_capture(cubeb_stream * stm, cubeb_stream_params * params)
 }
 
 static int
-opensl_configure_playback(cubeb_stream * stm, cubeb_stream_params * params) {
+opensl_configure_playback(cubeb_stream * stm, cubeb_stream_params * params)
+{
   assert(stm);
   assert(params);
 
   stm->user_output_rate = params->rate;
-  if(params->format == CUBEB_SAMPLE_S16NE || params->format == CUBEB_SAMPLE_S16BE) {
+  if (params->format == CUBEB_SAMPLE_S16NE ||
+      params->format == CUBEB_SAMPLE_S16BE) {
     stm->framesize = params->channels * sizeof(int16_t);
-  } else if(params->format == CUBEB_SAMPLE_FLOAT32NE || params->format == CUBEB_SAMPLE_FLOAT32BE) {
+  } else if (params->format == CUBEB_SAMPLE_FLOAT32NE ||
+             params->format == CUBEB_SAMPLE_FLOAT32BE) {
     stm->framesize = params->channels * sizeof(float);
   }
   stm->lastPosition = -1;
   stm->lastPositionTimeStamp = 0;
   stm->lastCompensativePosition = -1;
 
-  void* format = NULL;
-  SLuint32* format_sample_rate = NULL;
+  void * format = NULL;
+  SLuint32 * format_sample_rate = NULL;
 
 #if defined(__ANDROID__) && (__ANDROID_API__ >= ANDROID_VERSION_LOLLIPOP)
   SLAndroidDataFormat_PCM_EX pcm_ext_format;
@@ -1088,8 +1119,8 @@ opensl_configure_playback(cubeb_stream * stm, cubeb_stream_params * params) {
 #endif
 
   SLDataFormat_PCM pcm_format;
-  if(!format) {
-    if(opensl_set_format(&pcm_format, params) != CUBEB_OK) {
+  if (!format) {
+    if (opensl_set_format(&pcm_format, params) != CUBEB_OK) {
       return CUBEB_ERROR_INVALID_FORMAT;
     }
     format = &pcm_format;
@@ -1124,13 +1155,9 @@ opensl_configure_playback(cubeb_stream * stm, cubeb_stream_params * params) {
   uint32_t preferred_sampling_rate = stm->user_output_rate;
   SLresult res = SL_RESULT_CONTENT_UNSUPPORTED;
   if (preferred_sampling_rate) {
-    res = (*stm->context->eng)->CreateAudioPlayer(stm->context->eng,
-                                                  &stm->playerObj,
-                                                  &source,
-                                                  &sink,
-                                                  NELEMS(ids),
-                                                  ids,
-                                                  req);
+    res = (*stm->context->eng)
+              ->CreateAudioPlayer(stm->context->eng, &stm->playerObj, &source,
+                                  &sink, NELEMS(ids), ids, req);
   }
 
   // Sample rate not supported? Try again with primary sample rate!
@@ -1138,13 +1165,9 @@ opensl_configure_playback(cubeb_stream * stm, cubeb_stream_params * params) {
       preferred_sampling_rate != DEFAULT_SAMPLE_RATE) {
     preferred_sampling_rate = DEFAULT_SAMPLE_RATE;
     *format_sample_rate = preferred_sampling_rate * 1000;
-    res = (*stm->context->eng)->CreateAudioPlayer(stm->context->eng,
-                                                  &stm->playerObj,
-                                                  &source,
-                                                  &sink,
-                                                  NELEMS(ids),
-                                                  ids,
-                                                  req);
+    res = (*stm->context->eng)
+              ->CreateAudioPlayer(stm->context->eng, &stm->playerObj, &source,
+                                  &sink, NELEMS(ids), ids, req);
   }
 
   if (res != SL_RESULT_SUCCESS) {
@@ -1160,10 +1183,11 @@ opensl_configure_playback(cubeb_stream * stm, cubeb_stream_params * params) {
   stm->queuebuf_capacity = NBUFS;
   if (stm->output_enabled) {
     // Full duplex, update capacity to hold 1 sec of data
-    stm->queuebuf_capacity = 1 * stm->output_configured_rate / stm->queuebuf_len;
+    stm->queuebuf_capacity =
+        1 * stm->output_configured_rate / stm->queuebuf_len;
   }
   // Allocate input array
-  stm->queuebuf = (void**)calloc(1, sizeof(void*) * stm->queuebuf_capacity);
+  stm->queuebuf = (void **)calloc(1, sizeof(void *) * stm->queuebuf_capacity);
   for (uint32_t i = 0; i < stm->queuebuf_capacity; ++i) {
     stm->queuebuf[i] = calloc(1, stm->queuebuf_len);
     assert(stm->queuebuf[i]);
@@ -1177,7 +1201,8 @@ opensl_configure_playback(cubeb_stream * stm, cubeb_stream_params * params) {
                              stm->context->SL_IID_ANDROIDCONFIGURATION,
                              &playerConfig);
     if (res != SL_RESULT_SUCCESS) {
-      LOG("Failed to get Android configuration interface. Error code: %lu", res);
+      LOG("Failed to get Android configuration interface. Error code: %lu",
+          res);
       return CUBEB_ERROR;
     }
 
@@ -1185,10 +1210,9 @@ opensl_configure_playback(cubeb_stream * stm, cubeb_stream_params * params) {
     if (stm->voice_output) {
       streamType = SL_ANDROID_STREAM_VOICE;
     }
-    res = (*playerConfig)->SetConfiguration(playerConfig,
-                                            SL_ANDROID_KEY_STREAM_TYPE,
-                                            &streamType,
-                                            sizeof(streamType));
+    res = (*playerConfig)
+              ->SetConfiguration(playerConfig, SL_ANDROID_KEY_STREAM_TYPE,
+                                 &streamType, sizeof(streamType));
     if (res != SL_RESULT_SUCCESS) {
       LOG("Failed to set Android configuration to %d Error code: %lu",
           streamType, res);
@@ -1199,13 +1223,14 @@ opensl_configure_playback(cubeb_stream * stm, cubeb_stream_params * params) {
       performanceMode = SL_ANDROID_PERFORMANCE_POWER_SAVING;
     }
 
-    res = (*playerConfig)->SetConfiguration(playerConfig,
-                                            SL_ANDROID_KEY_PERFORMANCE_MODE,
-                                            &performanceMode,
-                                            sizeof(performanceMode));
+    res = (*playerConfig)
+              ->SetConfiguration(playerConfig, SL_ANDROID_KEY_PERFORMANCE_MODE,
+                                 &performanceMode, sizeof(performanceMode));
     if (res != SL_RESULT_SUCCESS) {
-      LOG("Failed to set Android performance mode to %d Error code: %lu. This is"
-          " not fatal", performanceMode, res);
+      LOG("Failed to set Android performance mode to %d Error code: %lu. This "
+          "is"
+          " not fatal",
+          performanceMode, res);
     }
   }
 
@@ -1229,10 +1254,10 @@ opensl_configure_playback(cubeb_stream * stm, cubeb_stream_params * params) {
   SLuint32 paramSize = sizeof(SLuint32);
   // The reported latency is in milliseconds.
   if (playerConfig) {
-    res = (*playerConfig)->GetConfiguration(playerConfig,
-                                            (const SLchar *)"androidGetAudioLatency",
-                                            &paramSize,
-                                            &audioLatency);
+    res = (*playerConfig)
+              ->GetConfiguration(playerConfig,
+                                 (const SLchar *)"androidGetAudioLatency",
+                                 &paramSize, &audioLatency);
     if (res == SL_RESULT_SUCCESS) {
       LOG("Got playback latency using android configuration extension");
       stm->output_latency_ms = audioLatency;
@@ -1241,11 +1266,12 @@ opensl_configure_playback(cubeb_stream * stm, cubeb_stream_params * params) {
   // `playerConfig` is available, but the above failed, or `playerConfig` is not
   // available. In both cases, we need to acquire the output latency by an other
   // mean.
-  if ((playerConfig && res != SL_RESULT_SUCCESS) ||
-      !playerConfig) {
-    if (cubeb_output_latency_method_is_loaded(stm->context->p_output_latency_function)) {
+  if ((playerConfig && res != SL_RESULT_SUCCESS) || !playerConfig) {
+    if (cubeb_output_latency_method_is_loaded(
+            stm->context->p_output_latency_function)) {
       LOG("Got playback latency using JNI");
-      stm->output_latency_ms = cubeb_get_output_latency(stm->context->p_output_latency_function);
+      stm->output_latency_ms =
+          cubeb_get_output_latency(stm->context->p_output_latency_function);
     } else {
       LOG("No alternate latency querying method loaded, A/V sync will be off.");
       stm->output_latency_ms = 0;
@@ -1254,25 +1280,25 @@ opensl_configure_playback(cubeb_stream * stm, cubeb_stream_params * params) {
 
   LOG("Audio output latency: %dms", stm->output_latency_ms);
 
-  res = (*stm->playerObj)->GetInterface(stm->playerObj,
-                                        stm->context->SL_IID_PLAY,
-                                        &stm->play);
+  res =
+      (*stm->playerObj)
+          ->GetInterface(stm->playerObj, stm->context->SL_IID_PLAY, &stm->play);
   if (res != SL_RESULT_SUCCESS) {
     LOG("Failed to get play interface. Error code: %lu", res);
     return CUBEB_ERROR;
   }
 
-  res = (*stm->playerObj)->GetInterface(stm->playerObj,
-                                        stm->context->SL_IID_BUFFERQUEUE,
-                                        &stm->bufq);
+  res = (*stm->playerObj)
+            ->GetInterface(stm->playerObj, stm->context->SL_IID_BUFFERQUEUE,
+                           &stm->bufq);
   if (res != SL_RESULT_SUCCESS) {
     LOG("Failed to get bufferqueue interface. Error code: %lu", res);
     return CUBEB_ERROR;
   }
 
-  res = (*stm->playerObj)->GetInterface(stm->playerObj,
-                                        stm->context->SL_IID_VOLUME,
-                                        &stm->volume);
+  res = (*stm->playerObj)
+            ->GetInterface(stm->playerObj, stm->context->SL_IID_VOLUME,
+                           &stm->volume);
   if (res != SL_RESULT_SUCCESS) {
     LOG("Failed to get volume interface. Error code: %lu", res);
     return CUBEB_ERROR;
@@ -1287,7 +1313,9 @@ opensl_configure_playback(cubeb_stream * stm, cubeb_stream_params * params) {
   // Work around wilhelm/AudioTrack badness, bug 1221228
   (*stm->play)->SetMarkerPosition(stm->play, (SLmillisecond)0);
 
-  res = (*stm->play)->SetCallbackEventsMask(stm->play, (SLuint32)SL_PLAYEVENT_HEADATMARKER);
+  res = (*stm->play)
+            ->SetCallbackEventsMask(stm->play,
+                                    (SLuint32)SL_PLAYEVENT_HEADATMARKER);
   if (res != SL_RESULT_SUCCESS) {
     LOG("Failed to set headatmarker event mask. Error code: %lu", res);
     return CUBEB_ERROR;
@@ -1308,7 +1336,7 @@ opensl_configure_playback(cubeb_stream * stm, cubeb_stream_params * params) {
     // will be consumed and kick off the buffer queue callback.
     // Note the duration of a single frame is less than 1ms. We don't bother
     // adjusting the playback position.
-    uint8_t *buf = stm->queuebuf[stm->queuebuf_idx++];
+    uint8_t * buf = stm->queuebuf[stm->queuebuf_idx++];
     memset(buf, 0, stm->framesize);
     res = (*stm->bufq)->Enqueue(stm->bufq, buf, stm->framesize);
     assert(res == SL_RESULT_SUCCESS);
@@ -1325,48 +1353,48 @@ opensl_validate_stream_param(cubeb_stream_params * stream_params)
        (stream_params->channels < 1 || stream_params->channels > 32))) {
     return CUBEB_ERROR_INVALID_FORMAT;
   }
-  if ((stream_params &&
-       (stream_params->prefs & CUBEB_STREAM_PREF_LOOPBACK))) {
+  if ((stream_params && (stream_params->prefs & CUBEB_STREAM_PREF_LOOPBACK))) {
     LOG("Loopback is not supported");
     return CUBEB_ERROR_NOT_SUPPORTED;
   }
   return CUBEB_OK;
 }
 
-int has_pref_set(cubeb_stream_params* input_params,
-                 cubeb_stream_params* output_params,
-                 cubeb_stream_prefs pref)
+int
+has_pref_set(cubeb_stream_params * input_params,
+             cubeb_stream_params * output_params, cubeb_stream_prefs pref)
 {
   return (input_params && input_params->prefs & pref) ||
          (output_params && output_params->prefs & pref);
 }
 
 static int
-opensl_stream_init(cubeb * ctx, cubeb_stream ** stream, char const * stream_name,
-                   cubeb_devid input_device,
+opensl_stream_init(cubeb * ctx, cubeb_stream ** stream,
+                   char const * stream_name, cubeb_devid input_device,
                    cubeb_stream_params * input_stream_params,
                    cubeb_devid output_device,
                    cubeb_stream_params * output_stream_params,
                    unsigned int latency_frames,
-                   cubeb_data_callback data_callback, cubeb_state_callback state_callback,
-                   void * user_ptr)
+                   cubeb_data_callback data_callback,
+                   cubeb_state_callback state_callback, void * user_ptr)
 {
   cubeb_stream * stm;
 
   assert(ctx);
   if (input_device || output_device) {
-    LOG("Device selection is not supported in Android. The default will be used");
+    LOG("Device selection is not supported in Android. The default will be "
+        "used");
   }
 
   *stream = NULL;
 
   int r = opensl_validate_stream_param(output_stream_params);
-  if(r != CUBEB_OK) {
+  if (r != CUBEB_OK) {
     LOG("Output stream params not valid");
     return r;
   }
   r = opensl_validate_stream_param(input_stream_params);
-  if(r != CUBEB_OK) {
+  if (r != CUBEB_OK) {
     LOG("Input stream params not valid");
     return r;
   }
@@ -1378,15 +1406,19 @@ opensl_stream_init(cubeb * ctx, cubeb_stream ** stream, char const * stream_name
   stm->data_callback = data_callback;
   stm->state_callback = state_callback;
   stm->user_ptr = user_ptr;
-  stm->buffer_size_frames = latency_frames ? latency_frames : DEFAULT_NUM_OF_FRAMES;
+  stm->buffer_size_frames =
+      latency_frames ? latency_frames : DEFAULT_NUM_OF_FRAMES;
   stm->input_enabled = (input_stream_params) ? 1 : 0;
   stm->output_enabled = (output_stream_params) ? 1 : 0;
   stm->shutdown = 1;
-  stm->voice_input = has_pref_set(input_stream_params, NULL, CUBEB_STREAM_PREF_VOICE);
-  stm->voice_output = has_pref_set(NULL, output_stream_params, CUBEB_STREAM_PREF_VOICE);
+  stm->voice_input =
+      has_pref_set(input_stream_params, NULL, CUBEB_STREAM_PREF_VOICE);
+  stm->voice_output =
+      has_pref_set(NULL, output_stream_params, CUBEB_STREAM_PREF_VOICE);
 
-  LOG("cubeb stream prefs: voice_input: %s voice_output: %s", stm->voice_input ? "true" : "false",
-                                                              stm->voice_output ? "true" : "false");
+  LOG("cubeb stream prefs: voice_input: %s voice_output: %s",
+      stm->voice_input ? "true" : "false",
+      stm->voice_output ? "true" : "false");
 
 #ifdef DEBUG
   pthread_mutexattr_t attr;
@@ -1399,7 +1431,8 @@ opensl_stream_init(cubeb * ctx, cubeb_stream ** stream, char const * stream_name
   assert(r == 0);
 
   if (output_stream_params) {
-    LOG("Playback params: Rate %d, channels %d, format %d, latency in frames %d.",
+    LOG("Playback params: Rate %d, channels %d, format %d, latency in frames "
+        "%d.",
         output_stream_params->rate, output_stream_params->channels,
         output_stream_params->format, stm->buffer_size_frames);
     r = opensl_configure_playback(stm, output_stream_params);
@@ -1410,7 +1443,8 @@ opensl_stream_init(cubeb * ctx, cubeb_stream ** stream, char const * stream_name
   }
 
   if (input_stream_params) {
-    LOG("Capture params: Rate %d, channels %d, format %d, latency in frames %d.",
+    LOG("Capture params: Rate %d, channels %d, format %d, latency in frames "
+        "%d.",
         input_stream_params->rate, input_stream_params->channels,
         input_stream_params->format, stm->buffer_size_frames);
     r = opensl_configure_capture(stm, input_stream_params);
@@ -1442,13 +1476,10 @@ opensl_stream_init(cubeb * ctx, cubeb_stream ** stream, char const * stream_name
     output_params.rate = stm->output_configured_rate;
   }
 
-  stm->resampler = cubeb_resampler_create(stm,
-                                          input_stream_params ? &input_params : NULL,
-                                          output_stream_params ? &output_params : NULL,
-                                          target_sample_rate,
-                                          data_callback,
-                                          user_ptr,
-                                          CUBEB_RESAMPLER_QUALITY_DEFAULT);
+  stm->resampler = cubeb_resampler_create(
+      stm, input_stream_params ? &input_params : NULL,
+      output_stream_params ? &output_params : NULL, target_sample_rate,
+      data_callback, user_ptr, CUBEB_RESAMPLER_QUALITY_DEFAULT);
   if (!stm->resampler) {
     LOG("Failed to create resampler");
     opensl_stream_destroy(stm);
@@ -1468,7 +1499,7 @@ opensl_start_player(cubeb_stream * stm)
   (*stm->playerObj)->GetState(stm->playerObj, &playerState);
   if (playerState == SL_OBJECT_STATE_REALIZED) {
     SLresult res = (*stm->play)->SetPlayState(stm->play, SL_PLAYSTATE_PLAYING);
-    if(res != SL_RESULT_SUCCESS) {
+    if (res != SL_RESULT_SUCCESS) {
       LOG("Failed to start player. Error code: %lu", res);
       return CUBEB_ERROR;
     }
@@ -1483,8 +1514,10 @@ opensl_start_recorder(cubeb_stream * stm)
   SLuint32 recorderState;
   (*stm->recorderObj)->GetState(stm->recorderObj, &recorderState);
   if (recorderState == SL_OBJECT_STATE_REALIZED) {
-    SLresult res = (*stm->recorderItf)->SetRecordState(stm->recorderItf, SL_RECORDSTATE_RECORDING);
-    if(res != SL_RESULT_SUCCESS) {
+    SLresult res =
+        (*stm->recorderItf)
+            ->SetRecordState(stm->recorderItf, SL_RECORDSTATE_RECORDING);
+    if (res != SL_RESULT_SUCCESS) {
       LOG("Failed to start recorder. Error code: %lu", res);
       return CUBEB_ERROR;
     }
@@ -1544,7 +1577,8 @@ opensl_stop_recorder(cubeb_stream * stm)
   assert(stm->recorderObj);
   assert(stm->shutdown || stm->draining);
 
-  SLresult res = (*stm->recorderItf)->SetRecordState(stm->recorderItf, SL_RECORDSTATE_PAUSED);
+  SLresult res = (*stm->recorderItf)
+                     ->SetRecordState(stm->recorderItf, SL_RECORDSTATE_PAUSED);
   if (res != SL_RESULT_SUCCESS) {
     LOG("Failed to stop recorder. Error code: %lu", res);
     return CUBEB_ERROR;
@@ -1590,7 +1624,8 @@ opensl_destroy_recorder(cubeb_stream * stm)
   assert(stm->recorderObj);
 
   if (stm->recorderBufferQueueItf) {
-    SLresult res = (*stm->recorderBufferQueueItf)->Clear(stm->recorderBufferQueueItf);
+    SLresult res =
+        (*stm->recorderBufferQueueItf)->Clear(stm->recorderBufferQueueItf);
     if (res != SL_RESULT_SUCCESS) {
       LOG("Failed to clear recorder buffer queue. Error code: %lu", res);
       return CUBEB_ERROR;
@@ -1656,11 +1691,12 @@ opensl_stream_get_position(cubeb_stream * stm, uint64_t * position)
 
   struct timespec t;
   clock_gettime(CLOCK_MONOTONIC, &t);
-  if(stm->lastPosition == msec) {
+  if (stm->lastPosition == msec) {
     compensation_msec =
-      (t.tv_sec*1000000000LL + t.tv_nsec - stm->lastPositionTimeStamp) / 1000000;
+        (t.tv_sec * 1000000000LL + t.tv_nsec - stm->lastPositionTimeStamp) /
+        1000000;
   } else {
-    stm->lastPositionTimeStamp = t.tv_sec*1000000000LL + t.tv_nsec;
+    stm->lastPositionTimeStamp = t.tv_sec * 1000000000LL + t.tv_nsec;
     stm->lastPosition = msec;
   }
 
@@ -1668,7 +1704,8 @@ opensl_stream_get_position(cubeb_stream * stm, uint64_t * position)
   uint32_t output_latency = stm->output_latency_ms;
 
   pthread_mutex_lock(&stm->mutex);
-  int64_t maximum_position = stm->written * (int64_t)stm->user_output_rate / stm->output_configured_rate;
+  int64_t maximum_position = stm->written * (int64_t)stm->user_output_rate /
+                             stm->output_configured_rate;
   pthread_mutex_unlock(&stm->mutex);
   assert(maximum_position >= 0);
 
@@ -1677,14 +1714,14 @@ opensl_stream_get_position(cubeb_stream * stm, uint64_t * position)
     if (stm->lastCompensativePosition > msec + compensation_msec) {
       // Over compensation, use lastCompensativePosition.
       unadjusted_position =
-        samplerate * (stm->lastCompensativePosition - output_latency) / 1000;
+          samplerate * (stm->lastCompensativePosition - output_latency) / 1000;
     } else {
       unadjusted_position =
-        samplerate * (msec - output_latency + compensation_msec) / 1000;
+          samplerate * (msec - output_latency + compensation_msec) / 1000;
       stm->lastCompensativePosition = msec + compensation_msec;
     }
-    *position = unadjusted_position < maximum_position ?
-      unadjusted_position : maximum_position;
+    *position = unadjusted_position < maximum_position ? unadjusted_position
+                                                       : maximum_position;
   } else {
     *position = 0;
   }
@@ -1698,7 +1735,7 @@ opensl_stream_get_latency(cubeb_stream * stm, uint32_t * latency)
   assert(latency);
 
   uint32_t stream_latency_frames =
-    stm->user_output_rate * stm->output_latency_ms / 1000;
+      stm->user_output_rate * stm->output_latency_ms / 1000;
 
   return stream_latency_frames + cubeb_resampler_latency(stm->resampler);
 }
@@ -1735,25 +1772,24 @@ opensl_stream_set_volume(cubeb_stream * stm, float volume)
 }
 
 static struct cubeb_ops const opensl_ops = {
-  .init = opensl_init,
-  .get_backend_id = opensl_get_backend_id,
-  .get_max_channel_count = opensl_get_max_channel_count,
-  .get_min_latency = NULL,
-  .get_preferred_sample_rate = NULL,
-  .enumerate_devices = NULL,
-  .device_collection_destroy = NULL,
-  .destroy = opensl_destroy,
-  .stream_init = opensl_stream_init,
-  .stream_destroy = opensl_stream_destroy,
-  .stream_start = opensl_stream_start,
-  .stream_stop = opensl_stream_stop,
-  .stream_get_position = opensl_stream_get_position,
-  .stream_get_latency = opensl_stream_get_latency,
-  .stream_get_input_latency = NULL,
-  .stream_set_volume = opensl_stream_set_volume,
-  .stream_set_name = NULL,
-  .stream_get_current_device = NULL,
-  .stream_device_destroy = NULL,
-  .stream_register_device_changed_callback = NULL,
-  .register_device_collection_changed = NULL
-};
+    .init = opensl_init,
+    .get_backend_id = opensl_get_backend_id,
+    .get_max_channel_count = opensl_get_max_channel_count,
+    .get_min_latency = NULL,
+    .get_preferred_sample_rate = NULL,
+    .enumerate_devices = NULL,
+    .device_collection_destroy = NULL,
+    .destroy = opensl_destroy,
+    .stream_init = opensl_stream_init,
+    .stream_destroy = opensl_stream_destroy,
+    .stream_start = opensl_stream_start,
+    .stream_stop = opensl_stream_stop,
+    .stream_get_position = opensl_stream_get_position,
+    .stream_get_latency = opensl_stream_get_latency,
+    .stream_get_input_latency = NULL,
+    .stream_set_volume = opensl_stream_set_volume,
+    .stream_set_name = NULL,
+    .stream_get_current_device = NULL,
+    .stream_device_destroy = NULL,
+    .stream_register_device_changed_callback = NULL,
+    .register_device_collection_changed = NULL};
diff --git a/src/cubeb_oss.c b/src/cubeb_oss.c
index edec029..083c37f 100644
--- a/src/cubeb_oss.c
+++ b/src/cubeb_oss.c
@@ -10,25 +10,25 @@
  * accompanying file LICENSE for details.
  */
 
+#include "cubeb-internal.h"
+#include "cubeb/cubeb.h"
+#include "cubeb_mixer.h"
+#include "cubeb_strings.h"
 #include <assert.h>
 #include <ctype.h>
-#include <limits.h>
 #include <errno.h>
-#include <sys/types.h>
-#include <sys/soundcard.h>
-#include <sys/ioctl.h>
 #include <fcntl.h>
-#include <unistd.h>
+#include <limits.h>
+#include <poll.h>
 #include <pthread.h>
 #include <stdbool.h>
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
-#include <poll.h>
-#include "cubeb/cubeb.h"
-#include "cubeb_mixer.h"
-#include "cubeb_strings.h"
-#include "cubeb-internal.h"
+#include <sys/ioctl.h>
+#include <sys/soundcard.h>
+#include <sys/types.h>
+#include <unistd.h>
 
 /* Supported well by most hardware. */
 #ifndef OSS_PREFER_RATE
@@ -55,25 +55,25 @@
 #define ENV_AUDIO_DEVICE "AUDIO_DEVICE"
 
 #ifndef OSS_MAX_CHANNELS
-# if defined(__FreeBSD__) || defined(__DragonFly__)
+#if defined(__FreeBSD__) || defined(__DragonFly__)
 /*
  * The current maximum number of channels supported
  * on FreeBSD is 8.
  *
  * Reference: FreeBSD 12.1-RELEASE
  */
-#  define OSS_MAX_CHANNELS (8)
-# elif defined(__sun__)
+#define OSS_MAX_CHANNELS (8)
+#elif defined(__sun__)
 /*
  * The current maximum number of channels supported
  * on Illumos is 16.
  *
  * Reference: PSARC 2008/318
  */
-#  define OSS_MAX_CHANNELS (16)
-# else
-#  define OSS_MAX_CHANNELS (2)
-# endif
+#define OSS_MAX_CHANNELS (16)
+#else
+#define OSS_MAX_CHANNELS (2)
+#endif
 #endif
 
 #if defined(__FreeBSD__) || defined(__DragonFly__)
@@ -89,7 +89,7 @@ struct cubeb {
 
   /* Our intern string store */
   pthread_mutex_t mutex; /* protects devid_strs */
-  cubeb_strings *devid_strs;
+  cubeb_strings * devid_strs;
 };
 
 struct oss_stream {
@@ -112,14 +112,14 @@ struct cubeb_stream {
   struct cubeb * context;
   void * user_ptr;
   pthread_t thread;
-  bool doorbell; /* (m) */
+  bool doorbell;              /* (m) */
   pthread_cond_t doorbell_cv; /* (m) */
-  pthread_cond_t stopped_cv; /* (m) */
+  pthread_cond_t stopped_cv;  /* (m) */
   pthread_mutex_t mtx; /* Members protected by this should be marked (m) */
   bool thread_created; /* (m) */
-  bool running; /* (m) */
-  bool destroying; /* (m) */
-  cubeb_state state; /* (m) */
+  bool running;        /* (m) */
+  bool destroying;     /* (m) */
+  cubeb_state state;   /* (m) */
   float volume /* (m) */;
   struct oss_stream play;
   struct oss_stream record;
@@ -132,9 +132,9 @@ struct cubeb_stream {
 };
 
 static char const *
-oss_cubeb_devid_intern(cubeb *context, char const * devid)
+oss_cubeb_devid_intern(cubeb * context, char const * devid)
 {
-  char const *is;
+  char const * is;
   pthread_mutex_lock(&context->mutex);
   is = cubeb_strings_intern(context->devid_strs, devid);
   pthread_mutex_unlock(&context->mutex);
@@ -142,7 +142,8 @@ oss_cubeb_devid_intern(cubeb *context, char const * devid)
 }
 
 int
-oss_init(cubeb **context, char const *context_name) {
+oss_init(cubeb ** context, char const * context_name)
+{
   cubeb * c;
 
   (void)context_name;
@@ -211,7 +212,7 @@ oss_get_min_latency(cubeb * context, cubeb_stream_params params,
 }
 
 static void
-oss_free_cubeb_device_info_strings(cubeb_device_info *cdi)
+oss_free_cubeb_device_info_strings(cubeb_device_info * cdi)
 {
   free((char *)cdi->device_id);
   free((char *)cdi->friendly_name);
@@ -230,8 +231,8 @@ oss_free_cubeb_device_info_strings(cubeb_device_info *cdi)
  * Return 0 if OK, otherwise 1.
  */
 static int
-oss_probe_open(const char *dsppath, cubeb_device_type type,
-               int *fdp, oss_audioinfo *resai)
+oss_probe_open(const char * dsppath, cubeb_device_type type, int * fdp,
+               oss_audioinfo * resai)
 {
   oss_audioinfo ai;
   int error;
@@ -258,81 +259,81 @@ oss_probe_open(const char *dsppath, cubeb_device_type type,
 
 struct sndstat_info {
   oss_devnode_t devname;
-  const char *desc;
+  const char * desc;
   cubeb_device_type type;
   int preferred;
 };
 
 static int
-oss_sndstat_line_parse(char *line, int is_ud, struct sndstat_info *sinfo)
+oss_sndstat_line_parse(char * line, int is_ud, struct sndstat_info * sinfo)
 {
-    char *matchptr = line, *n = NULL;
-    struct sndstat_info res;
-
-    memset(&res, 0, sizeof(res));
-
-    n = strchr(matchptr, ':');
-    if (n == NULL)
-      goto fail;
-    if (is_ud == 0) {
-      unsigned int devunit;
+  char *matchptr = line, *n = NULL;
+  struct sndstat_info res;
 
-      if (sscanf(matchptr, "pcm%u: ", &devunit) < 1)
-        goto fail;
+  memset(&res, 0, sizeof(res));
 
-      if (snprintf(res.devname, sizeof(res.devname), "/dev/dsp%u", devunit) < 1)
-        goto fail;
-    } else {
-      if (n - matchptr >= (ssize_t)(sizeof(res.devname) - strlen("/dev/")))
-        goto fail;
+  n = strchr(matchptr, ':');
+  if (n == NULL)
+    goto fail;
+  if (is_ud == 0) {
+    unsigned int devunit;
 
-      strlcpy(res.devname, "/dev/", sizeof(res.devname));
-      strncat(res.devname, matchptr, n - matchptr);
-    }
-    matchptr = n + 1;
+    if (sscanf(matchptr, "pcm%u: ", &devunit) < 1)
+      goto fail;
 
-    n = strchr(matchptr, '<');
-    if (n == NULL)
+    if (snprintf(res.devname, sizeof(res.devname), "/dev/dsp%u", devunit) < 1)
       goto fail;
-    matchptr = n + 1;
-    n = strrchr(matchptr, '>');
-    if (n == NULL)
+  } else {
+    if (n - matchptr >= (ssize_t)(sizeof(res.devname) - strlen("/dev/")))
       goto fail;
-    *n = 0;
-    res.desc = matchptr;
-    matchptr = n + 1;
 
-    n = strchr(matchptr, '(');
-    if (n == NULL)
-      goto fail;
-    matchptr = n + 1;
-    n = strrchr(matchptr, ')');
-    if (n == NULL)
+    strlcpy(res.devname, "/dev/", sizeof(res.devname));
+    strncat(res.devname, matchptr, n - matchptr);
+  }
+  matchptr = n + 1;
+
+  n = strchr(matchptr, '<');
+  if (n == NULL)
+    goto fail;
+  matchptr = n + 1;
+  n = strrchr(matchptr, '>');
+  if (n == NULL)
+    goto fail;
+  *n = 0;
+  res.desc = matchptr;
+  matchptr = n + 1;
+
+  n = strchr(matchptr, '(');
+  if (n == NULL)
+    goto fail;
+  matchptr = n + 1;
+  n = strrchr(matchptr, ')');
+  if (n == NULL)
+    goto fail;
+  *n = 0;
+  if (!isdigit(matchptr[0])) {
+    if (strstr(matchptr, "play") != NULL)
+      res.type |= CUBEB_DEVICE_TYPE_OUTPUT;
+    if (strstr(matchptr, "rec") != NULL)
+      res.type |= CUBEB_DEVICE_TYPE_INPUT;
+  } else {
+    int p, r;
+    if (sscanf(matchptr, "%dp:%*dv/%dr:%*dv", &p, &r) != 2)
       goto fail;
-    *n = 0;
-    if (!isdigit(matchptr[0])) {
-      if (strstr(matchptr, "play") != NULL)
-        res.type |= CUBEB_DEVICE_TYPE_OUTPUT;
-      if (strstr(matchptr, "rec") != NULL)
-        res.type |= CUBEB_DEVICE_TYPE_INPUT;
-    } else {
-      int p, r;
-      if (sscanf(matchptr, "%dp:%*dv/%dr:%*dv", &p, &r) != 2)
-        goto fail;
-      if (p > 0)
-        res.type |= CUBEB_DEVICE_TYPE_OUTPUT;
-      if (r > 0)
-        res.type |= CUBEB_DEVICE_TYPE_INPUT;
-    }
-    matchptr = n + 1;
-    if (strstr(matchptr, "default") != NULL)
-      res.preferred = 1;
+    if (p > 0)
+      res.type |= CUBEB_DEVICE_TYPE_OUTPUT;
+    if (r > 0)
+      res.type |= CUBEB_DEVICE_TYPE_INPUT;
+  }
+  matchptr = n + 1;
+  if (strstr(matchptr, "default") != NULL)
+    res.preferred = 1;
 
-    *sinfo = res;
-    return 0;
+  *sinfo = res;
+  return 0;
 
 fail:
-    return 1;
+  return 1;
 }
 
 /*
@@ -344,10 +345,10 @@ static int
 oss_enumerate_devices(cubeb * context, cubeb_device_type type,
                       cubeb_device_collection * collection)
 {
-  cubeb_device_info *devinfop = NULL;
-  char *line = NULL;
+  cubeb_device_info * devinfop = NULL;
+  char * line = NULL;
   size_t linecap = 0;
-  FILE *sndstatfp = NULL;
+  FILE * sndstatfp = NULL;
   int collection_cnt = 0;
   int is_ud = 0;
   int skipall = 0;
@@ -360,7 +361,7 @@ oss_enumerate_devices(cubeb * context, cubeb_device_type type,
   if (sndstatfp == NULL)
     goto fail;
   while (getline(&line, &linecap, sndstatfp) > 0) {
-    const char *devid = NULL;
+    const char * devid = NULL;
     struct sndstat_info sinfo;
     oss_audioinfo ai;
 
@@ -373,7 +374,8 @@ oss_enumerate_devices(cubeb * context, cubeb_device_type type,
       skipall = 0;
       continue;
     }
-    if (!strncmp(line, SNDSTAT_USER_BEGIN_STR, strlen(SNDSTAT_USER_BEGIN_STR))) {
+    if (!strncmp(line, SNDSTAT_USER_BEGIN_STR,
+                 strlen(SNDSTAT_USER_BEGIN_STR))) {
       is_ud = 1;
       skipall = 0;
       continue;
@@ -433,8 +435,8 @@ oss_enumerate_devices(cubeb * context, cubeb_device_type type,
 
     collection_cnt++;
 
-    void *newp = reallocarray(devinfop, collection_cnt + 1,
-                              sizeof(cubeb_device_info));
+    void * newp =
+        reallocarray(devinfop, collection_cnt + 1, sizeof(cubeb_device_info));
     if (newp == NULL)
       goto fail;
     devinfop = newp;
@@ -464,7 +466,7 @@ oss_enumerate_devices(cubeb * context, cubeb_device_type type,
 {
   oss_sysinfo si;
   int error, i;
-  cubeb_device_info *devinfop = NULL;
+  cubeb_device_info * devinfop = NULL;
   int collection_cnt = 0;
   int mixer_fd = -1;
 
@@ -476,7 +478,8 @@ oss_enumerate_devices(cubeb * context, cubeb_device_type type,
 
   error = ioctl(mixer_fd, SNDCTL_SYSINFO, &si);
   if (error) {
-    LOG("Failed to run SNDCTL_SYSINFO on mixer %s. errno: %d", OSS_DEFAULT_MIXER, errno);
+    LOG("Failed to run SNDCTL_SYSINFO on mixer %s. errno: %d",
+        OSS_DEFAULT_MIXER, errno);
     goto fail;
   }
 
@@ -487,8 +490,8 @@ oss_enumerate_devices(cubeb * context, cubeb_device_type type,
   collection->count = 0;
   for (i = 0; i < si.numaudios; i++) {
     oss_audioinfo ai;
-    cubeb_device_info cdi = { 0 };
-    const char *devid = NULL;
+    cubeb_device_info cdi = {0};
+    const char * devid = NULL;
 
     ai.dev = i;
     error = ioctl(mixer_fd, SNDCTL_AUDIOINFO, &ai);
@@ -574,24 +577,24 @@ static unsigned int
 oss_chn_from_cubeb(cubeb_channel chn)
 {
   switch (chn) {
-    case CHANNEL_FRONT_LEFT:
-      return CHID_L;
-    case CHANNEL_FRONT_RIGHT:
-      return CHID_R;
-    case CHANNEL_FRONT_CENTER:
-      return CHID_C;
-    case CHANNEL_LOW_FREQUENCY:
-      return CHID_LFE;
-    case CHANNEL_BACK_LEFT:
-      return CHID_LR;
-    case CHANNEL_BACK_RIGHT:
-      return CHID_RR;
-    case CHANNEL_SIDE_LEFT:
-      return CHID_LS;
-    case CHANNEL_SIDE_RIGHT:
-      return CHID_RS;
-    default:
-      return CHID_UNDEF;
+  case CHANNEL_FRONT_LEFT:
+    return CHID_L;
+  case CHANNEL_FRONT_RIGHT:
+    return CHID_R;
+  case CHANNEL_FRONT_CENTER:
+    return CHID_C;
+  case CHANNEL_LOW_FREQUENCY:
+    return CHID_LFE;
+  case CHANNEL_BACK_LEFT:
+    return CHID_LR;
+  case CHANNEL_BACK_RIGHT:
+    return CHID_RR;
+  case CHANNEL_SIDE_LEFT:
+    return CHID_LS;
+  case CHANNEL_SIDE_RIGHT:
+    return CHID_RS;
+  default:
+    return CHID_UNDEF;
   }
 }
 
@@ -648,7 +651,8 @@ oss_copy_params(int fd, cubeb_stream * stream, cubeb_stream_params * params,
     return CUBEB_ERROR;
   }
   /* Mono layout is an exception */
-  if (params->layout != CUBEB_LAYOUT_UNDEFINED && params->layout != CUBEB_LAYOUT_MONO) {
+  if (params->layout != CUBEB_LAYOUT_UNDEFINED &&
+      params->layout != CUBEB_LAYOUT_MONO) {
     chnorder = oss_cubeb_layout_to_chnorder(params->layout);
     if (ioctl(fd, SNDCTL_DSP_SET_CHNORDER, &chnorder) == -1)
       LOG("Non-fatal error %d occured when setting channel order.", errno);
@@ -748,7 +752,8 @@ oss_get_rec_frames(cubeb_stream * s, unsigned int nframes)
   size_t read_ofs = 0;
   while (rem > 0) {
     ssize_t n;
-    if ((n = read(s->record.fd, (uint8_t *)s->record.buf + read_ofs, rem)) < 0) {
+    if ((n = read(s->record.fd, (uint8_t *)s->record.buf + read_ofs, rem)) <
+        0) {
       if (errno == EINTR)
         continue;
       return CUBEB_ERROR;
@@ -759,7 +764,6 @@ oss_get_rec_frames(cubeb_stream * s, unsigned int nframes)
   return 0;
 }
 
-
 static int
 oss_put_play_frames(cubeb_stream * s, unsigned int nframes)
 {
@@ -821,7 +825,7 @@ oss_wait_recfd_for_space(cubeb_stream * s)
 
 /* 1 - Stopped by cubeb_stream_stop, otherwise 0 */
 static int
-oss_audio_loop(cubeb_stream * s, cubeb_state *new_state)
+oss_audio_loop(cubeb_stream * s, cubeb_state * new_state)
 {
   cubeb_state state = CUBEB_STATE_STOPPED;
   int trig = 0, drain = 0;
@@ -903,7 +907,7 @@ oss_audio_loop(cubeb_stream * s, cubeb_state *new_state)
           oss_float_to_linear32(s->play.buf, s->play.info.channels * got, vol);
         } else {
           oss_linear16_set_vol((int16_t *)s->play.buf,
-              s->play.info.channels * got, vol);
+                               s->play.info.channels * got, vol);
         }
         if (oss_put_play_frames(s, got) == CUBEB_ERROR) {
           state = CUBEB_STATE_ERROR;
@@ -968,9 +972,9 @@ breakdown:
 }
 
 static void *
-oss_io_routine(void *arg)
+oss_io_routine(void * arg)
 {
-  cubeb_stream *s = arg;
+  cubeb_stream * s = arg;
   cubeb_state new_state;
   int stopped;
 
@@ -1024,22 +1028,18 @@ oss_get_frag_params(unsigned int shift)
 }
 
 static int
-oss_stream_init(cubeb * context,
-                cubeb_stream ** stream,
-                char const * stream_name,
-                cubeb_devid input_device,
+oss_stream_init(cubeb * context, cubeb_stream ** stream,
+                char const * stream_name, cubeb_devid input_device,
                 cubeb_stream_params * input_stream_params,
                 cubeb_devid output_device,
                 cubeb_stream_params * output_stream_params,
-                unsigned int latency_frames,
-                cubeb_data_callback data_callback,
-                cubeb_state_callback state_callback,
-                void * user_ptr)
+                unsigned int latency_frames, cubeb_data_callback data_callback,
+                cubeb_state_callback state_callback, void * user_ptr)
 {
   int ret = CUBEB_OK;
   unsigned int playnfr = 0, recnfr = 0;
-  cubeb_stream *s = NULL;
-  const char *defdsp;
+  cubeb_stream * s = NULL;
+  const char * defdsp;
 
   if (!(defdsp = getenv(ENV_AUDIO_DEVICE)) || *defdsp == '\0')
     defdsp = OSS_DEFAULT_DEVICE;
@@ -1072,7 +1072,8 @@ oss_stream_init(cubeb * context,
     nb_channels = cubeb_channel_layout_nb_channels(input_stream_params->layout);
     if (input_stream_params->layout != CUBEB_LAYOUT_UNDEFINED &&
         nb_channels != input_stream_params->channels) {
-      LOG("input_stream_params->layout does not match input_stream_params->channels");
+      LOG("input_stream_params->layout does not match "
+          "input_stream_params->channels");
       ret = CUBEB_ERROR_INVALID_PARAMETER;
       goto error;
     }
@@ -1089,9 +1090,12 @@ oss_stream_init(cubeb * context,
       LOG("Setting record params failed");
       goto error;
     }
-    s->record.floating = (input_stream_params->format == CUBEB_SAMPLE_FLOAT32NE);
-    s->record.frame_size = s->record.info.channels * (s->record.info.precision / 8);
-    recnfr = (1 << oss_calc_frag_shift(s->nfr, s->record.frame_size)) / s->record.frame_size;
+    s->record.floating =
+        (input_stream_params->format == CUBEB_SAMPLE_FLOAT32NE);
+    s->record.frame_size =
+        s->record.info.channels * (s->record.info.precision / 8);
+    recnfr = (1 << oss_calc_frag_shift(s->nfr, s->record.frame_size)) /
+             s->record.frame_size;
   }
   if (output_stream_params != NULL) {
     unsigned int nb_channels;
@@ -1100,10 +1104,12 @@ oss_stream_init(cubeb * context,
       ret = CUBEB_ERROR_NOT_SUPPORTED;
       goto error;
     }
-    nb_channels = cubeb_channel_layout_nb_channels(output_stream_params->layout);
+    nb_channels =
+        cubeb_channel_layout_nb_channels(output_stream_params->layout);
     if (output_stream_params->layout != CUBEB_LAYOUT_UNDEFINED &&
         nb_channels != output_stream_params->channels) {
-      LOG("output_stream_params->layout does not match output_stream_params->channels");
+      LOG("output_stream_params->layout does not match "
+          "output_stream_params->channels");
       ret = CUBEB_ERROR_INVALID_PARAMETER;
       goto error;
     }
@@ -1122,17 +1128,19 @@ oss_stream_init(cubeb * context,
     }
     s->play.floating = (output_stream_params->format == CUBEB_SAMPLE_FLOAT32NE);
     s->play.frame_size = s->play.info.channels * (s->play.info.precision / 8);
-    playnfr = (1 << oss_calc_frag_shift(s->nfr, s->play.frame_size)) / s->play.frame_size;
+    playnfr = (1 << oss_calc_frag_shift(s->nfr, s->play.frame_size)) /
+              s->play.frame_size;
   }
   /*
-   * Use the largest nframes among playing and recording streams to set OSS buffer size.
-   * After that, use the smallest allocated nframes among both direction to allocate our
-   * temporary buffers.
+   * Use the largest nframes among playing and recording streams to set OSS
+   * buffer size. After that, use the smallest allocated nframes among both
+   * direction to allocate our temporary buffers.
    */
   s->nfr = (playnfr > recnfr) ? playnfr : recnfr;
   s->nfrags = OSS_NFRAGS;
   if (s->play.fd != -1) {
-    int frag = oss_get_frag_params(oss_calc_frag_shift(s->nfr, s->play.frame_size));
+    int frag =
+        oss_get_frag_params(oss_calc_frag_shift(s->nfr, s->play.frame_size));
     if (ioctl(s->play.fd, SNDCTL_DSP_SETFRAGMENT, &frag))
       LOG("Failed to set play fd with SNDCTL_DSP_SETFRAGMENT. frag: 0x%x",
           frag);
@@ -1145,7 +1153,8 @@ oss_stream_init(cubeb * context,
     }
   }
   if (s->record.fd != -1) {
-    int frag = oss_get_frag_params(oss_calc_frag_shift(s->nfr, s->record.frame_size));
+    int frag =
+        oss_get_frag_params(oss_calc_frag_shift(s->nfr, s->record.frame_size));
     if (ioctl(s->record.fd, SNDCTL_DSP_SETFRAGMENT, &frag))
       LOG("Failed to set record fd with SNDCTL_DSP_SETFRAGMENT. frag: 0x%x",
           frag);
@@ -1279,10 +1288,10 @@ oss_get_current_device(cubeb_stream * stream, cubeb_device ** const device)
   if (*device == NULL) {
     return CUBEB_ERROR;
   }
-  (*device)->input_name = stream->record.fd != -1 ?
-    strdup(stream->record.name) : NULL;
-  (*device)->output_name = stream->play.fd != -1 ?
-    strdup(stream->play.name) : NULL;
+  (*device)->input_name =
+      stream->record.fd != -1 ? strdup(stream->record.name) : NULL;
+  (*device)->output_name =
+      stream->play.fd != -1 ? strdup(stream->play.name) : NULL;
   return CUBEB_OK;
 }
 
diff --git a/src/cubeb_osx_run_loop.cpp b/src/cubeb_osx_run_loop.cpp
index de4e439..5828db6 100644
--- a/src/cubeb_osx_run_loop.cpp
+++ b/src/cubeb_osx_run_loop.cpp
@@ -5,31 +5,29 @@
  * accompanying file LICENSE for details.
  */
 
-#include <cubeb/cubeb.h>
 #include "cubeb_osx_run_loop.h"
 #include "cubeb_log.h"
 #include <AudioUnit/AudioUnit.h>
 #include <CoreAudio/AudioHardware.h>
 #include <CoreAudio/HostTime.h>
 #include <CoreFoundation/CoreFoundation.h>
+#include <cubeb/cubeb.h>
 
-void cubeb_set_coreaudio_notification_runloop()
+void
+cubeb_set_coreaudio_notification_runloop()
 {
   /* This is needed so that AudioUnit listeners get called on this thread, and
    * not the main thread. If we don't do that, they are not called, or a crash
    * occur, depending on the OSX version. */
   AudioObjectPropertyAddress runloop_address = {
-    kAudioHardwarePropertyRunLoop,
-    kAudioObjectPropertyScopeGlobal,
-    kAudioObjectPropertyElementMaster
-  };
+      kAudioHardwarePropertyRunLoop, kAudioObjectPropertyScopeGlobal,
+      kAudioObjectPropertyElementMaster};
 
   CFRunLoopRef run_loop = nullptr;
 
   OSStatus r;
-  r = AudioObjectSetPropertyData(kAudioObjectSystemObject,
-                                 &runloop_address,
-                                 0, NULL, sizeof(CFRunLoopRef), &run_loop);
+  r = AudioObjectSetPropertyData(kAudioObjectSystemObject, &runloop_address, 0,
+                                 NULL, sizeof(CFRunLoopRef), &run_loop);
   if (r != noErr) {
     LOG("Could not make global CoreAudio notifications use their own thread.");
   }
diff --git a/src/cubeb_osx_run_loop.h b/src/cubeb_osx_run_loop.h
index 78cd68d..8d88a37 100644
--- a/src/cubeb_osx_run_loop.h
+++ b/src/cubeb_osx_run_loop.h
@@ -15,7 +15,8 @@
 extern "C" {
 #endif
 
-void cubeb_set_coreaudio_notification_runloop();
+void
+cubeb_set_coreaudio_notification_runloop();
 
 #if defined(__cplusplus)
 }
diff --git a/src/cubeb_pulse.c b/src/cubeb_pulse.c
index 6ab2091..31a2f93 100644
--- a/src/cubeb_pulse.c
+++ b/src/cubeb_pulse.c
@@ -5,88 +5,88 @@
  * accompanying file LICENSE for details.
  */
 #undef NDEBUG
+#include "cubeb-internal.h"
+#include "cubeb/cubeb.h"
+#include "cubeb_mixer.h"
+#include "cubeb_strings.h"
 #include <assert.h>
 #include <dlfcn.h>
 #include <pulse/pulseaudio.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include "cubeb-internal.h"
-#include "cubeb/cubeb.h"
-#include "cubeb_mixer.h"
-#include "cubeb_strings.h"
 
 #ifdef DISABLE_LIBPULSE_DLOPEN
 #define WRAP(x) x
 #else
 #define WRAP(x) cubeb_##x
-#define LIBPULSE_API_VISIT(X)                   \
-  X(pa_channel_map_can_balance)                 \
-  X(pa_channel_map_init)                        \
-  X(pa_context_connect)                         \
-  X(pa_context_disconnect)                      \
-  X(pa_context_drain)                           \
-  X(pa_context_get_server_info)                 \
-  X(pa_context_get_sink_info_by_name)           \
-  X(pa_context_get_sink_info_list)              \
-  X(pa_context_get_sink_input_info)             \
-  X(pa_context_get_source_info_list)            \
-  X(pa_context_get_state)                       \
-  X(pa_context_new)                             \
-  X(pa_context_rttime_new)                      \
-  X(pa_context_set_sink_input_volume)           \
-  X(pa_context_set_state_callback)              \
-  X(pa_context_unref)                           \
-  X(pa_cvolume_set)                             \
-  X(pa_cvolume_set_balance)                     \
-  X(pa_frame_size)                              \
-  X(pa_operation_get_state)                     \
-  X(pa_operation_unref)                         \
-  X(pa_proplist_gets)                           \
-  X(pa_rtclock_now)                             \
-  X(pa_stream_begin_write)                      \
-  X(pa_stream_cancel_write)                     \
-  X(pa_stream_connect_playback)                 \
-  X(pa_stream_cork)                             \
-  X(pa_stream_disconnect)                       \
-  X(pa_stream_get_channel_map)                  \
-  X(pa_stream_get_index)                        \
-  X(pa_stream_get_latency)                      \
-  X(pa_stream_get_sample_spec)                  \
-  X(pa_stream_get_state)                        \
-  X(pa_stream_get_time)                         \
-  X(pa_stream_new)                              \
-  X(pa_stream_set_state_callback)               \
-  X(pa_stream_set_write_callback)               \
-  X(pa_stream_unref)                            \
-  X(pa_stream_update_timing_info)               \
-  X(pa_stream_write)                            \
-  X(pa_sw_volume_from_linear)                   \
-  X(pa_threaded_mainloop_free)                  \
-  X(pa_threaded_mainloop_get_api)               \
-  X(pa_threaded_mainloop_in_thread)             \
-  X(pa_threaded_mainloop_lock)                  \
-  X(pa_threaded_mainloop_new)                   \
-  X(pa_threaded_mainloop_signal)                \
-  X(pa_threaded_mainloop_start)                 \
-  X(pa_threaded_mainloop_stop)                  \
-  X(pa_threaded_mainloop_unlock)                \
-  X(pa_threaded_mainloop_wait)                  \
-  X(pa_usec_to_bytes)                           \
-  X(pa_stream_set_read_callback)                \
-  X(pa_stream_connect_record)                   \
-  X(pa_stream_readable_size)                    \
-  X(pa_stream_writable_size)                    \
-  X(pa_stream_peek)                             \
-  X(pa_stream_drop)                             \
-  X(pa_stream_get_buffer_attr)                  \
-  X(pa_stream_get_device_name)                  \
-  X(pa_context_set_subscribe_callback)          \
-  X(pa_context_subscribe)                       \
-  X(pa_mainloop_api_once)                       \
-  X(pa_get_library_version)                     \
-  X(pa_channel_map_init_auto)                   \
-  X(pa_stream_set_name)                         \
+#define LIBPULSE_API_VISIT(X)                                                  \
+  X(pa_channel_map_can_balance)                                                \
+  X(pa_channel_map_init)                                                       \
+  X(pa_context_connect)                                                        \
+  X(pa_context_disconnect)                                                     \
+  X(pa_context_drain)                                                          \
+  X(pa_context_get_server_info)                                                \
+  X(pa_context_get_sink_info_by_name)                                          \
+  X(pa_context_get_sink_info_list)                                             \
+  X(pa_context_get_sink_input_info)                                            \
+  X(pa_context_get_source_info_list)                                           \
+  X(pa_context_get_state)                                                      \
+  X(pa_context_new)                                                            \
+  X(pa_context_rttime_new)                                                     \
+  X(pa_context_set_sink_input_volume)                                          \
+  X(pa_context_set_state_callback)                                             \
+  X(pa_context_unref)                                                          \
+  X(pa_cvolume_set)                                                            \
+  X(pa_cvolume_set_balance)                                                    \
+  X(pa_frame_size)                                                             \
+  X(pa_operation_get_state)                                                    \
+  X(pa_operation_unref)                                                        \
+  X(pa_proplist_gets)                                                          \
+  X(pa_rtclock_now)                                                            \
+  X(pa_stream_begin_write)                                                     \
+  X(pa_stream_cancel_write)                                                    \
+  X(pa_stream_connect_playback)                                                \
+  X(pa_stream_cork)                                                            \
+  X(pa_stream_disconnect)                                                      \
+  X(pa_stream_get_channel_map)                                                 \
+  X(pa_stream_get_index)                                                       \
+  X(pa_stream_get_latency)                                                     \
+  X(pa_stream_get_sample_spec)                                                 \
+  X(pa_stream_get_state)                                                       \
+  X(pa_stream_get_time)                                                        \
+  X(pa_stream_new)                                                             \
+  X(pa_stream_set_state_callback)                                              \
+  X(pa_stream_set_write_callback)                                              \
+  X(pa_stream_unref)                                                           \
+  X(pa_stream_update_timing_info)                                              \
+  X(pa_stream_write)                                                           \
+  X(pa_sw_volume_from_linear)                                                  \
+  X(pa_threaded_mainloop_free)                                                 \
+  X(pa_threaded_mainloop_get_api)                                              \
+  X(pa_threaded_mainloop_in_thread)                                            \
+  X(pa_threaded_mainloop_lock)                                                 \
+  X(pa_threaded_mainloop_new)                                                  \
+  X(pa_threaded_mainloop_signal)                                               \
+  X(pa_threaded_mainloop_start)                                                \
+  X(pa_threaded_mainloop_stop)                                                 \
+  X(pa_threaded_mainloop_unlock)                                               \
+  X(pa_threaded_mainloop_wait)                                                 \
+  X(pa_usec_to_bytes)                                                          \
+  X(pa_stream_set_read_callback)                                               \
+  X(pa_stream_connect_record)                                                  \
+  X(pa_stream_readable_size)                                                   \
+  X(pa_stream_writable_size)                                                   \
+  X(pa_stream_peek)                                                            \
+  X(pa_stream_drop)                                                            \
+  X(pa_stream_get_buffer_attr)                                                 \
+  X(pa_stream_get_device_name)                                                 \
+  X(pa_context_set_subscribe_callback)                                         \
+  X(pa_context_subscribe)                                                      \
+  X(pa_mainloop_api_once)                                                      \
+  X(pa_get_library_version)                                                    \
+  X(pa_channel_map_init_auto)                                                  \
+  X(pa_stream_set_name)
 
 #define MAKE_TYPEDEF(x) static typeof(x) * cubeb_##x;
 LIBPULSE_API_VISIT(MAKE_TYPEDEF);
@@ -139,11 +139,7 @@ struct cubeb_stream {
 
 static const float PULSE_NO_GAIN = -1.0;
 
-enum cork_state {
-  UNCORK = 0,
-  CORK = 1 << 0,
-  NOTIFY = 1 << 1
-};
+enum cork_state { UNCORK = 0, CORK = 1 << 0, NOTIFY = 1 << 1 };
 
 static int
 intern_device_id(cubeb * ctx, char const ** id)
@@ -164,14 +160,16 @@ intern_device_id(cubeb * ctx, char const ** id)
 }
 
 static void
-sink_info_callback(pa_context * context, const pa_sink_info * info, int eol, void * u)
+sink_info_callback(pa_context * context, const pa_sink_info * info, int eol,
+                   void * u)
 {
   (void)context;
   cubeb * ctx = u;
   if (!eol) {
     free(ctx->default_sink_info);
     ctx->default_sink_info = malloc(sizeof(struct cubeb_default_sink_info));
-    memcpy(&ctx->default_sink_info->channel_map, &info->channel_map, sizeof(pa_channel_map));
+    memcpy(&ctx->default_sink_info->channel_map, &info->channel_map,
+           sizeof(pa_channel_map));
     ctx->default_sink_info->sample_spec_rate = info->sample_spec.rate;
     ctx->default_sink_info->flags = info->flags;
   }
@@ -179,10 +177,12 @@ sink_info_callback(pa_context * context, const pa_sink_info * info, int eol, voi
 }
 
 static void
-server_info_callback(pa_context * context, const pa_server_info * info, void * u)
+server_info_callback(pa_context * context, const pa_server_info * info,
+                     void * u)
 {
   pa_operation * o;
-  o = WRAP(pa_context_get_sink_info_by_name)(context, info->default_sink_name, sink_info_callback, u);
+  o = WRAP(pa_context_get_sink_info_by_name)(context, info->default_sink_name,
+                                             sink_info_callback, u);
   if (o) {
     WRAP(pa_operation_unref)(o);
   }
@@ -223,7 +223,8 @@ stream_state_change_callback(cubeb_stream * stm, cubeb_state s)
 }
 
 static void
-stream_drain_callback(pa_mainloop_api * a, pa_time_event * e, struct timeval const * tv, void * u)
+stream_drain_callback(pa_mainloop_api * a, pa_time_event * e,
+                      struct timeval const * tv, void * u)
 {
   (void)a;
   (void)tv;
@@ -247,7 +248,8 @@ stream_state_callback(pa_stream * s, void * u)
 }
 
 static void
-trigger_user_callback(pa_stream * s, void const * input_data, size_t nbytes, cubeb_stream * stm)
+trigger_user_callback(pa_stream * s, void const * input_data, size_t nbytes,
+                      cubeb_stream * stm)
 {
   void * buffer;
   size_t size;
@@ -264,13 +266,17 @@ trigger_user_callback(pa_stream * s, void const * input_data, size_t nbytes, cub
   while (towrite) {
     size = towrite;
     r = WRAP(pa_stream_begin_write)(s, &buffer, &size);
-    // Note: this has failed running under rr on occassion - needs investigation.
+    // Note: this has failed running under rr on occassion - needs
+    // investigation.
     assert(r == 0);
     assert(size > 0);
     assert(size % frame_size == 0);
 
-    LOGV("Trigger user callback with output buffer size=%zd, read_offset=%zd", size, read_offset);
-    got = stm->data_callback(stm, stm->user_ptr, (uint8_t const *)input_data + read_offset, buffer, size / frame_size);
+    LOGV("Trigger user callback with output buffer size=%zd, read_offset=%zd",
+         size, read_offset);
+    got = stm->data_callback(stm, stm->user_ptr,
+                             (uint8_t const *)input_data + read_offset, buffer,
+                             size / frame_size);
     if (got < 0) {
       WRAP(pa_stream_cancel_write)(s);
       stm->shutdown = 1;
@@ -283,7 +289,7 @@ trigger_user_callback(pa_stream * s, void const * input_data, size_t nbytes, cub
     }
 
     if (stm->volume != PULSE_NO_GAIN) {
-      uint32_t samples =  size * stm->output_sample_spec.channels / frame_size ;
+      uint32_t samples = size * stm->output_sample_spec.channels / frame_size;
 
       if (stm->output_sample_spec.format == PA_SAMPLE_S16BE ||
           stm->output_sample_spec.format == PA_SAMPLE_S16LE) {
@@ -299,10 +305,11 @@ trigger_user_callback(pa_stream * s, void const * input_data, size_t nbytes, cub
       }
     }
 
-    r = WRAP(pa_stream_write)(s, buffer, got * frame_size, NULL, 0, PA_SEEK_RELATIVE);
+    r = WRAP(pa_stream_write)(s, buffer, got * frame_size, NULL, 0,
+                              PA_SEEK_RELATIVE);
     assert(r == 0);
 
-    if ((size_t) got < size / frame_size) {
+    if ((size_t)got < size / frame_size) {
       pa_usec_t latency = 0;
       r = WRAP(pa_stream_get_latency)(s, &latency, NULL);
       if (r == -PA_ERR_NODATA) {
@@ -313,7 +320,9 @@ trigger_user_callback(pa_stream * s, void const * input_data, size_t nbytes, cub
       /* pa_stream_drain is useless, see PA bug# 866. this is a workaround. */
       /* arbitrary safety margin: double the current latency. */
       assert(!stm->drain_timer);
-      stm->drain_timer = WRAP(pa_context_rttime_new)(stm->context->context, WRAP(pa_rtclock_now)() + 2 * latency, stream_drain_callback, stm);
+      stm->drain_timer = WRAP(pa_context_rttime_new)(
+          stm->context->context, WRAP(pa_rtclock_now)() + 2 * latency,
+          stream_drain_callback, stm);
       stm->shutdown = 1;
       return;
     }
@@ -341,12 +350,11 @@ stream_write_callback(pa_stream * s, size_t nbytes, void * u)
 {
   LOGV("Output callback to be written buffer size %zd", nbytes);
   cubeb_stream * stm = u;
-  if (stm->shutdown ||
-      stm->state != CUBEB_STATE_STARTED) {
+  if (stm->shutdown || stm->state != CUBEB_STATE_STARTED) {
     return;
   }
 
-  if (!stm->input_stream){
+  if (!stm->input_stream) {
     // Output/playback only operation.
     // Write directly to output
     assert(!stm->input_stream && stm->output_stream);
@@ -379,8 +387,9 @@ stream_read_callback(pa_stream * s, size_t nbytes, void * u)
         trigger_user_callback(stm->output_stream, read_data, write_size, stm);
       } else {
         // input/capture only operation. Call callback directly
-        long got = stm->data_callback(stm, stm->user_ptr, read_data, NULL, read_frames);
-        if (got < 0 || (size_t) got != read_frames) {
+        long got = stm->data_callback(stm, stm->user_ptr, read_data, NULL,
+                                      read_frames);
+        if (got < 0 || (size_t)got != read_frames) {
           WRAP(pa_stream_cancel_write)(s);
           stm->shutdown = 1;
           break;
@@ -414,7 +423,7 @@ wait_until_context_ready(cubeb * ctx)
 static int
 wait_until_io_stream_ready(pa_stream * stream, pa_threaded_mainloop * mainloop)
 {
-  if (!stream || !mainloop){
+  if (!stream || !mainloop) {
     return -1;
   }
   for (;;) {
@@ -432,11 +441,13 @@ static int
 wait_until_stream_ready(cubeb_stream * stm)
 {
   if (stm->output_stream &&
-      wait_until_io_stream_ready(stm->output_stream, stm->context->mainloop) == -1) {
+      wait_until_io_stream_ready(stm->output_stream, stm->context->mainloop) ==
+          -1) {
     return -1;
   }
-  if(stm->input_stream &&
-     wait_until_io_stream_ready(stm->input_stream, stm->context->mainloop) == -1) {
+  if (stm->input_stream &&
+      wait_until_io_stream_ready(stm->input_stream, stm->context->mainloop) ==
+          -1) {
     return -1;
   }
   return 0;
@@ -464,7 +475,8 @@ cork_io_stream(cubeb_stream * stm, pa_stream * io_stream, enum cork_state state)
   if (!io_stream) {
     return;
   }
-  o = WRAP(pa_stream_cork)(io_stream, state & CORK, stream_success_callback, stm);
+  o = WRAP(pa_stream_cork)(io_stream, state & CORK, stream_success_callback,
+                           stm);
   if (o) {
     operation_wait(stm->context, io_stream, o);
     WRAP(pa_operation_unref)(o);
@@ -491,7 +503,8 @@ stream_update_timing_info(cubeb_stream * stm)
   int r = -1;
   pa_operation * o = NULL;
   if (stm->output_stream) {
-    o = WRAP(pa_stream_update_timing_info)(stm->output_stream, stream_success_callback, stm);
+    o = WRAP(pa_stream_update_timing_info)(stm->output_stream,
+                                           stream_success_callback, stm);
     if (o) {
       r = operation_wait(stm->context, stm->output_stream, o);
       WRAP(pa_operation_unref)(o);
@@ -502,7 +515,8 @@ stream_update_timing_info(cubeb_stream * stm)
   }
 
   if (stm->input_stream) {
-    o = WRAP(pa_stream_update_timing_info)(stm->input_stream, stream_success_callback, stm);
+    o = WRAP(pa_stream_update_timing_info)(stm->input_stream,
+                                           stream_success_callback, stm);
     if (o) {
       r = operation_wait(stm->context, stm->input_stream, o);
       WRAP(pa_operation_unref)(o);
@@ -516,44 +530,44 @@ static pa_channel_position_t
 cubeb_channel_to_pa_channel(cubeb_channel channel)
 {
   switch (channel) {
-    case CHANNEL_FRONT_LEFT:
-      return PA_CHANNEL_POSITION_FRONT_LEFT;
-    case CHANNEL_FRONT_RIGHT:
-      return PA_CHANNEL_POSITION_FRONT_RIGHT;
-    case CHANNEL_FRONT_CENTER:
-      return PA_CHANNEL_POSITION_FRONT_CENTER;
-    case CHANNEL_LOW_FREQUENCY:
-      return PA_CHANNEL_POSITION_LFE;
-    case CHANNEL_BACK_LEFT:
-      return PA_CHANNEL_POSITION_REAR_LEFT;
-    case CHANNEL_BACK_RIGHT:
-      return PA_CHANNEL_POSITION_REAR_RIGHT;
-    case CHANNEL_FRONT_LEFT_OF_CENTER:
-      return PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER;
-    case CHANNEL_FRONT_RIGHT_OF_CENTER:
-      return PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER;
-    case CHANNEL_BACK_CENTER:
-      return PA_CHANNEL_POSITION_REAR_CENTER;
-    case CHANNEL_SIDE_LEFT:
-      return PA_CHANNEL_POSITION_SIDE_LEFT;
-    case CHANNEL_SIDE_RIGHT:
-      return PA_CHANNEL_POSITION_SIDE_RIGHT;
-    case CHANNEL_TOP_CENTER:
-      return PA_CHANNEL_POSITION_TOP_CENTER;
-    case CHANNEL_TOP_FRONT_LEFT:
-      return PA_CHANNEL_POSITION_TOP_FRONT_LEFT;
-    case CHANNEL_TOP_FRONT_CENTER:
-      return PA_CHANNEL_POSITION_TOP_FRONT_CENTER;
-    case CHANNEL_TOP_FRONT_RIGHT:
-      return PA_CHANNEL_POSITION_TOP_FRONT_RIGHT;
-    case CHANNEL_TOP_BACK_LEFT:
-      return PA_CHANNEL_POSITION_TOP_REAR_LEFT;
-    case CHANNEL_TOP_BACK_CENTER:
-      return PA_CHANNEL_POSITION_TOP_REAR_CENTER;
-    case CHANNEL_TOP_BACK_RIGHT:
-      return PA_CHANNEL_POSITION_TOP_REAR_RIGHT;
-    default:
-      return PA_CHANNEL_POSITION_INVALID;
+  case CHANNEL_FRONT_LEFT:
+    return PA_CHANNEL_POSITION_FRONT_LEFT;
+  case CHANNEL_FRONT_RIGHT:
+    return PA_CHANNEL_POSITION_FRONT_RIGHT;
+  case CHANNEL_FRONT_CENTER:
+    return PA_CHANNEL_POSITION_FRONT_CENTER;
+  case CHANNEL_LOW_FREQUENCY:
+    return PA_CHANNEL_POSITION_LFE;
+  case CHANNEL_BACK_LEFT:
+    return PA_CHANNEL_POSITION_REAR_LEFT;
+  case CHANNEL_BACK_RIGHT:
+    return PA_CHANNEL_POSITION_REAR_RIGHT;
+  case CHANNEL_FRONT_LEFT_OF_CENTER:
+    return PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER;
+  case CHANNEL_FRONT_RIGHT_OF_CENTER:
+    return PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER;
+  case CHANNEL_BACK_CENTER:
+    return PA_CHANNEL_POSITION_REAR_CENTER;
+  case CHANNEL_SIDE_LEFT:
+    return PA_CHANNEL_POSITION_SIDE_LEFT;
+  case CHANNEL_SIDE_RIGHT:
+    return PA_CHANNEL_POSITION_SIDE_RIGHT;
+  case CHANNEL_TOP_CENTER:
+    return PA_CHANNEL_POSITION_TOP_CENTER;
+  case CHANNEL_TOP_FRONT_LEFT:
+    return PA_CHANNEL_POSITION_TOP_FRONT_LEFT;
+  case CHANNEL_TOP_FRONT_CENTER:
+    return PA_CHANNEL_POSITION_TOP_FRONT_CENTER;
+  case CHANNEL_TOP_FRONT_RIGHT:
+    return PA_CHANNEL_POSITION_TOP_FRONT_RIGHT;
+  case CHANNEL_TOP_BACK_LEFT:
+    return PA_CHANNEL_POSITION_TOP_REAR_LEFT;
+  case CHANNEL_TOP_BACK_CENTER:
+    return PA_CHANNEL_POSITION_TOP_REAR_CENTER;
+  case CHANNEL_TOP_BACK_RIGHT:
+    return PA_CHANNEL_POSITION_TOP_REAR_RIGHT;
+  default:
+    return PA_CHANNEL_POSITION_INVALID;
   }
 }
 
@@ -566,7 +580,7 @@ layout_to_channel_map(cubeb_channel_layout layout, pa_channel_map * cm)
 
   uint32_t channels = 0;
   cubeb_channel_layout channelMap = layout;
-  for (uint32_t i = 0 ; channelMap != 0; ++i) {
+  for (uint32_t i = 0; channelMap != 0; ++i) {
     uint32_t channel = (channelMap & 1) << i;
     if (channel != 0) {
       cm->map[channels] = cubeb_channel_to_pa_channel(channel);
@@ -576,7 +590,7 @@ layout_to_channel_map(cubeb_channel_layout layout, pa_channel_map * cm)
   }
   unsigned int channels_from_layout = cubeb_channel_layout_nb_channels(layout);
   assert(channels_from_layout <= UINT8_MAX);
-  cm->channels = (uint8_t) channels_from_layout;
+  cm->channels = (uint8_t)channels_from_layout;
 
   // Special case single channel center mapping as mono.
   if (cm->channels == 1 && cm->map[0] == PA_CHANNEL_POSITION_FRONT_CENTER) {
@@ -584,8 +598,10 @@ layout_to_channel_map(cubeb_channel_layout layout, pa_channel_map * cm)
   }
 }
 
-static void pulse_context_destroy(cubeb * ctx);
-static void pulse_destroy(cubeb * ctx);
+static void
+pulse_context_destroy(cubeb * ctx);
+static void
+pulse_destroy(cubeb * ctx);
 
 static int
 pulse_context_init(cubeb * ctx)
@@ -597,12 +613,13 @@ pulse_context_init(cubeb * ctx)
     pulse_context_destroy(ctx);
   }
 
-  ctx->context = WRAP(pa_context_new)(WRAP(pa_threaded_mainloop_get_api)(ctx->mainloop),
-                                      ctx->context_name);
+  ctx->context = WRAP(pa_context_new)(
+      WRAP(pa_threaded_mainloop_get_api)(ctx->mainloop), ctx->context_name);
   if (!ctx->context) {
     return -1;
   }
-  WRAP(pa_context_set_state_callback)(ctx->context, context_state_callback, ctx);
+  WRAP(pa_context_set_state_callback)
+  (ctx->context, context_state_callback, ctx);
 
   WRAP(pa_threaded_mainloop_lock)(ctx->mainloop);
   r = WRAP(pa_context_connect)(ctx->context, NULL, 0, NULL);
@@ -621,8 +638,8 @@ pulse_context_init(cubeb * ctx)
   return 0;
 }
 
-static int pulse_subscribe_notifications(cubeb * context,
-                                         pa_subscription_mask_t mask);
+static int
+pulse_subscribe_notifications(cubeb * context, pa_subscription_mask_t mask);
 
 /*static*/ int
 pulse_init(cubeb ** context, char const * context_name)
@@ -642,12 +659,13 @@ pulse_init(cubeb ** context, char const * context_name)
     }
   }
 
-#define LOAD(x) {                               \
-    cubeb_##x = dlsym(libpulse, #x);            \
-    if (!cubeb_##x) {                           \
-      dlclose(libpulse);                        \
-      return CUBEB_ERROR;                       \
-    }                                           \
+#define LOAD(x)                                                                \
+  {                                                                            \
+    cubeb_##x = dlsym(libpulse, #x);                                           \
+    if (!cubeb_##x) {                                                          \
+      dlclose(libpulse);                                                       \
+      return CUBEB_ERROR;                                                      \
+    }                                                                          \
   }
 
   LIBPULSE_API_VISIT(LOAD);
@@ -655,7 +673,7 @@ pulse_init(cubeb ** context, char const * context_name)
 #endif
 
 #if PA_CHECK_VERSION(2, 0, 0)
-  const char* version = WRAP(pa_get_library_version)();
+  const char * version = WRAP(pa_get_library_version)();
   has_pulse_v2 = strtol(version, NULL, 10) >= 2;
 #endif
 
@@ -735,7 +753,8 @@ pulse_get_preferred_sample_rate(cubeb * ctx, uint32_t * rate)
 }
 
 static int
-pulse_get_min_latency(cubeb * ctx, cubeb_stream_params params, uint32_t * latency_frames)
+pulse_get_min_latency(cubeb * ctx, cubeb_stream_params params,
+                      uint32_t * latency_frames)
 {
   (void)ctx;
   // According to PulseAudio developers, this is a safe minimum.
@@ -785,7 +804,8 @@ pulse_destroy(cubeb * ctx)
   free(ctx);
 }
 
-static void pulse_stream_destroy(cubeb_stream * stm);
+static void
+pulse_stream_destroy(cubeb_stream * stm);
 
 static pa_sample_format_t
 to_pulse_format(cubeb_sample_format format)
@@ -807,33 +827,40 @@ to_pulse_format(cubeb_sample_format format)
 static cubeb_channel_layout
 pulse_default_layout_for_channels(uint32_t ch)
 {
-  assert (ch > 0 && ch <= 8);
+  assert(ch > 0 && ch <= 8);
   switch (ch) {
-    case 1: return CUBEB_LAYOUT_MONO;
-    case 2: return CUBEB_LAYOUT_STEREO;
-    case 3: return CUBEB_LAYOUT_3F;
-    case 4: return CUBEB_LAYOUT_QUAD;
-    case 5: return CUBEB_LAYOUT_3F2;
-    case 6: return CUBEB_LAYOUT_3F_LFE |
-                   CHANNEL_SIDE_LEFT | CHANNEL_SIDE_RIGHT;
-    case 7: return CUBEB_LAYOUT_3F3R_LFE;
-    case 8: return CUBEB_LAYOUT_3F4_LFE;
+  case 1:
+    return CUBEB_LAYOUT_MONO;
+  case 2:
+    return CUBEB_LAYOUT_STEREO;
+  case 3:
+    return CUBEB_LAYOUT_3F;
+  case 4:
+    return CUBEB_LAYOUT_QUAD;
+  case 5:
+    return CUBEB_LAYOUT_3F2;
+  case 6:
+    return CUBEB_LAYOUT_3F_LFE | CHANNEL_SIDE_LEFT | CHANNEL_SIDE_RIGHT;
+  case 7:
+    return CUBEB_LAYOUT_3F3R_LFE;
+  case 8:
+    return CUBEB_LAYOUT_3F4_LFE;
   }
   // Never get here!
   return CUBEB_LAYOUT_UNDEFINED;
 }
 
 static int
-create_pa_stream(cubeb_stream * stm,
-                 pa_stream ** pa_stm,
-                 cubeb_stream_params * stream_params,
-                 char const * stream_name)
+create_pa_stream(cubeb_stream * stm, pa_stream ** pa_stm,
+                 cubeb_stream_params * stream_params, char const * stream_name)
 {
   assert(stm && stream_params);
-  assert(&stm->input_stream == pa_stm || (&stm->output_stream == pa_stm &&
-         (stream_params->layout == CUBEB_LAYOUT_UNDEFINED ||
-         (stream_params->layout != CUBEB_LAYOUT_UNDEFINED &&
-         cubeb_channel_layout_nb_channels(stream_params->layout) == stream_params->channels))));
+  assert(&stm->input_stream == pa_stm ||
+         (&stm->output_stream == pa_stm &&
+          (stream_params->layout == CUBEB_LAYOUT_UNDEFINED ||
+           (stream_params->layout != CUBEB_LAYOUT_UNDEFINED &&
+            cubeb_channel_layout_nb_channels(stream_params->layout) ==
+                stream_params->channels))));
   if (stream_params->prefs & CUBEB_STREAM_PREF_LOOPBACK) {
     return CUBEB_ERROR_NOT_SUPPORTED;
   }
@@ -845,18 +872,23 @@ create_pa_stream(cubeb_stream * stm,
   ss.rate = stream_params->rate;
   if (stream_params->channels > UINT8_MAX)
     return CUBEB_ERROR_INVALID_FORMAT;
-  ss.channels = (uint8_t) stream_params->channels;
+  ss.channels = (uint8_t)stream_params->channels;
 
   if (stream_params->layout == CUBEB_LAYOUT_UNDEFINED) {
     pa_channel_map cm;
     if (stream_params->channels <= 8 &&
-       !WRAP(pa_channel_map_init_auto)(&cm, stream_params->channels, PA_CHANNEL_MAP_DEFAULT)) {
-      LOG("Layout undefined and PulseAudio's default layout has not been configured, guess one.");
-      layout_to_channel_map(pulse_default_layout_for_channels(stream_params->channels), &cm);
-      *pa_stm = WRAP(pa_stream_new)(stm->context->context, stream_name, &ss, &cm);
+        !WRAP(pa_channel_map_init_auto)(&cm, stream_params->channels,
+                                        PA_CHANNEL_MAP_DEFAULT)) {
+      LOG("Layout undefined and PulseAudio's default layout has not been "
+          "configured, guess one.");
+      layout_to_channel_map(
+          pulse_default_layout_for_channels(stream_params->channels), &cm);
+      *pa_stm =
+          WRAP(pa_stream_new)(stm->context->context, stream_name, &ss, &cm);
     } else {
       LOG("Layout undefined, PulseAudio will use its default.");
-      *pa_stm = WRAP(pa_stream_new)(stm->context->context, stream_name, &ss, NULL);
+      *pa_stm =
+          WRAP(pa_stream_new)(stm->context->context, stream_name, &ss, NULL);
     }
   } else {
     pa_channel_map cm;
@@ -867,33 +899,33 @@ create_pa_stream(cubeb_stream * stm,
 }
 
 static pa_buffer_attr
-set_buffering_attribute(unsigned int latency_frames, pa_sample_spec * sample_spec)
+set_buffering_attribute(unsigned int latency_frames,
+                        pa_sample_spec * sample_spec)
 {
   pa_buffer_attr battr;
   battr.maxlength = -1;
-  battr.prebuf    = -1;
-  battr.tlength   = latency_frames * WRAP(pa_frame_size)(sample_spec);
-  battr.minreq    = battr.tlength / 4;
-  battr.fragsize  = battr.minreq;
+  battr.prebuf = -1;
+  battr.tlength = latency_frames * WRAP(pa_frame_size)(sample_spec);
+  battr.minreq = battr.tlength / 4;
+  battr.fragsize = battr.minreq;
 
-  LOG("Requested buffer attributes maxlength %u, tlength %u, prebuf %u, minreq %u, fragsize %u",
-      battr.maxlength, battr.tlength, battr.prebuf, battr.minreq, battr.fragsize);
+  LOG("Requested buffer attributes maxlength %u, tlength %u, prebuf %u, minreq "
+      "%u, fragsize %u",
+      battr.maxlength, battr.tlength, battr.prebuf, battr.minreq,
+      battr.fragsize);
 
   return battr;
 }
 
 static int
-pulse_stream_init(cubeb * context,
-                  cubeb_stream ** stream,
-                  char const * stream_name,
-                  cubeb_devid input_device,
+pulse_stream_init(cubeb * context, cubeb_stream ** stream,
+                  char const * stream_name, cubeb_devid input_device,
                   cubeb_stream_params * input_stream_params,
                   cubeb_devid output_device,
                   cubeb_stream_params * output_stream_params,
                   unsigned int latency_frames,
                   cubeb_data_callback data_callback,
-                  cubeb_state_callback state_callback,
-                  void * user_ptr)
+                  cubeb_state_callback state_callback, void * user_ptr)
 {
   cubeb_stream * stm;
   pa_buffer_attr battr;
@@ -921,47 +953,53 @@ pulse_stream_init(cubeb * context,
 
   WRAP(pa_threaded_mainloop_lock)(stm->context->mainloop);
   if (output_stream_params) {
-    r = create_pa_stream(stm, &stm->output_stream, output_stream_params, stream_name);
+    r = create_pa_stream(stm, &stm->output_stream, output_stream_params,
+                         stream_name);
     if (r != CUBEB_OK) {
       WRAP(pa_threaded_mainloop_unlock)(stm->context->mainloop);
       pulse_stream_destroy(stm);
       return r;
     }
 
-    stm->output_sample_spec = *(WRAP(pa_stream_get_sample_spec)(stm->output_stream));
+    stm->output_sample_spec =
+        *(WRAP(pa_stream_get_sample_spec)(stm->output_stream));
 
-    WRAP(pa_stream_set_state_callback)(stm->output_stream, stream_state_callback, stm);
-    WRAP(pa_stream_set_write_callback)(stm->output_stream, stream_write_callback, stm);
+    WRAP(pa_stream_set_state_callback)
+    (stm->output_stream, stream_state_callback, stm);
+    WRAP(pa_stream_set_write_callback)
+    (stm->output_stream, stream_write_callback, stm);
 
     battr = set_buffering_attribute(latency_frames, &stm->output_sample_spec);
-    WRAP(pa_stream_connect_playback)(stm->output_stream,
-                                     (char const *) output_device,
-                                     &battr,
-                                     PA_STREAM_AUTO_TIMING_UPDATE | PA_STREAM_INTERPOLATE_TIMING |
-                                     PA_STREAM_START_CORKED | PA_STREAM_ADJUST_LATENCY,
-                                     NULL, NULL);
+    WRAP(pa_stream_connect_playback)
+    (stm->output_stream, (char const *)output_device, &battr,
+     PA_STREAM_AUTO_TIMING_UPDATE | PA_STREAM_INTERPOLATE_TIMING |
+         PA_STREAM_START_CORKED | PA_STREAM_ADJUST_LATENCY,
+     NULL, NULL);
   }
 
   // Set up input stream
   if (input_stream_params) {
-    r = create_pa_stream(stm, &stm->input_stream, input_stream_params, stream_name);
+    r = create_pa_stream(stm, &stm->input_stream, input_stream_params,
+                         stream_name);
     if (r != CUBEB_OK) {
       WRAP(pa_threaded_mainloop_unlock)(stm->context->mainloop);
       pulse_stream_destroy(stm);
       return r;
     }
 
-    stm->input_sample_spec = *(WRAP(pa_stream_get_sample_spec)(stm->input_stream));
+    stm->input_sample_spec =
+        *(WRAP(pa_stream_get_sample_spec)(stm->input_stream));
 
-    WRAP(pa_stream_set_state_callback)(stm->input_stream, stream_state_callback, stm);
-    WRAP(pa_stream_set_read_callback)(stm->input_stream, stream_read_callback, stm);
+    WRAP(pa_stream_set_state_callback)
+    (stm->input_stream, stream_state_callback, stm);
+    WRAP(pa_stream_set_read_callback)
+    (stm->input_stream, stream_read_callback, stm);
 
     battr = set_buffering_attribute(latency_frames, &stm->input_sample_spec);
-    WRAP(pa_stream_connect_record)(stm->input_stream,
-                                   (char const *) input_device,
-                                   &battr,
-                                   PA_STREAM_AUTO_TIMING_UPDATE | PA_STREAM_INTERPOLATE_TIMING |
-                                   PA_STREAM_START_CORKED | PA_STREAM_ADJUST_LATENCY);
+    WRAP(pa_stream_connect_record)
+    (stm->input_stream, (char const *)input_device, &battr,
+     PA_STREAM_AUTO_TIMING_UPDATE | PA_STREAM_INTERPOLATE_TIMING |
+         PA_STREAM_START_CORKED | PA_STREAM_ADJUST_LATENCY);
   }
 
   r = wait_until_stream_ready(stm);
@@ -979,18 +1017,22 @@ pulse_stream_init(cubeb * context,
   }
 
   if (g_cubeb_log_level) {
-    if (output_stream_params){
+    if (output_stream_params) {
       const pa_buffer_attr * output_att;
       output_att = WRAP(pa_stream_get_buffer_attr)(stm->output_stream);
-      LOG("Output buffer attributes maxlength %u, tlength %u, prebuf %u, minreq %u, fragsize %u",output_att->maxlength, output_att->tlength,
-          output_att->prebuf, output_att->minreq, output_att->fragsize);
+      LOG("Output buffer attributes maxlength %u, tlength %u, prebuf %u, "
+          "minreq %u, fragsize %u",
+          output_att->maxlength, output_att->tlength, output_att->prebuf,
+          output_att->minreq, output_att->fragsize);
     }
 
-    if (input_stream_params){
+    if (input_stream_params) {
       const pa_buffer_attr * input_att;
       input_att = WRAP(pa_stream_get_buffer_attr)(stm->input_stream);
-      LOG("Input buffer attributes maxlength %u, tlength %u, prebuf %u, minreq %u, fragsize %u",input_att->maxlength, input_att->tlength,
-          input_att->prebuf, input_att->minreq, input_att->fragsize);
+      LOG("Input buffer attributes maxlength %u, tlength %u, prebuf %u, minreq "
+          "%u, fragsize %u",
+          input_att->maxlength, input_att->tlength, input_att->prebuf,
+          input_att->minreq, input_att->fragsize);
     }
   }
 
@@ -1010,7 +1052,8 @@ pulse_stream_destroy(cubeb_stream * stm)
 
     if (stm->drain_timer) {
       /* there's no pa_rttime_free, so use this instead. */
-      WRAP(pa_threaded_mainloop_get_api)(stm->context->mainloop)->time_free(stm->drain_timer);
+      WRAP(pa_threaded_mainloop_get_api)
+      (stm->context->mainloop)->time_free(stm->drain_timer);
     }
 
     WRAP(pa_stream_set_state_callback)(stm->output_stream, NULL, NULL);
@@ -1054,8 +1097,9 @@ pulse_stream_start(cubeb_stream * stm)
      * things roll. This is done via a defer event in order to execute it
      * from PA server thread. */
     WRAP(pa_threaded_mainloop_lock)(stm->context->mainloop);
-    WRAP(pa_mainloop_api_once)(WRAP(pa_threaded_mainloop_get_api)(stm->context->mainloop),
-                               pulse_defer_event_cb, stm);
+    WRAP(pa_mainloop_api_once)
+    (WRAP(pa_threaded_mainloop_get_api)(stm->context->mainloop),
+     pulse_defer_event_cb, stm);
     WRAP(pa_threaded_mainloop_unlock)(stm->context->mainloop);
   }
 
@@ -1131,7 +1175,7 @@ pulse_stream_get_latency(cubeb_stream * stm, uint32_t * latency)
 }
 
 static void
-volume_success(pa_context *c, int success, void *userdata)
+volume_success(pa_context * c, int success, void * userdata)
 {
   (void)success;
   (void)c;
@@ -1141,7 +1185,7 @@ volume_success(pa_context *c, int success, void *userdata)
 }
 
 static void
-rename_success(pa_stream *s, int success, void *userdata)
+rename_success(pa_stream * s, int success, void * userdata)
 {
   cubeb_stream * stream = userdata;
   assert(success);
@@ -1178,9 +1222,8 @@ pulse_stream_set_volume(cubeb_stream * stm, float volume)
 
     index = WRAP(pa_stream_get_index)(stm->output_stream);
 
-    op = WRAP(pa_context_set_sink_input_volume)(ctx->context,
-                                                index, &cvol, volume_success,
-                                                stm);
+    op = WRAP(pa_context_set_sink_input_volume)(ctx->context, index, &cvol,
+                                                volume_success, stm);
     if (op) {
       operation_wait(ctx, stm->output_stream, op);
       WRAP(pa_operation_unref)(op);
@@ -1201,8 +1244,8 @@ pulse_stream_set_name(cubeb_stream * stm, char const * stream_name)
 
   WRAP(pa_threaded_mainloop_lock)(stm->context->mainloop);
 
-  pa_operation * op =
-    WRAP(pa_stream_set_name)(stm->output_stream, stream_name, rename_success, stm);
+  pa_operation * op = WRAP(pa_stream_set_name)(stm->output_stream, stream_name,
+                                               rename_success, stm);
 
   if (op) {
     operation_wait(stm->context, stm->output_stream, op);
@@ -1242,12 +1285,12 @@ pulse_format_to_cubeb_format(pa_sample_format_t format)
 }
 
 static void
-pulse_ensure_dev_list_data_list_size (pulse_dev_list_data * list_data)
+pulse_ensure_dev_list_data_list_size(pulse_dev_list_data * list_data)
 {
   if (list_data->count == list_data->max) {
     list_data->max += 8;
-    list_data->devinfo = realloc(list_data->devinfo,
-        sizeof(cubeb_device_info) * list_data->max);
+    list_data->devinfo =
+        realloc(list_data->devinfo, sizeof(cubeb_device_info) * list_data->max);
   }
 }
 
@@ -1267,8 +1310,8 @@ pulse_get_state_from_sink_port(pa_sink_port_info * info)
 }
 
 static void
-pulse_sink_info_cb(pa_context * context, const pa_sink_info * info,
-                   int eol, void * user_data)
+pulse_sink_info_cb(pa_context * context, const pa_sink_info * info, int eol,
+                   void * user_data)
 {
   pulse_dev_list_data * list_data = user_data;
   cubeb_device_info * devinfo;
@@ -1296,7 +1339,7 @@ pulse_sink_info_cb(pa_context * context, const pa_sink_info * info,
   memset(devinfo, 0, sizeof(cubeb_device_info));
 
   devinfo->device_id = device_id;
-  devinfo->devid = (cubeb_devid) devinfo->device_id;
+  devinfo->devid = (cubeb_devid)devinfo->device_id;
   devinfo->friendly_name = strdup(info->description);
   prop = WRAP(pa_proplist_gets)(info->proplist, "sysfs.path");
   if (prop)
@@ -1307,11 +1350,13 @@ pulse_sink_info_cb(pa_context * context, const pa_sink_info * info,
 
   devinfo->type = CUBEB_DEVICE_TYPE_OUTPUT;
   devinfo->state = pulse_get_state_from_sink_port(info->active_port);
-  devinfo->preferred = (strcmp(info->name, list_data->default_sink_name) == 0) ?
-    CUBEB_DEVICE_PREF_ALL : CUBEB_DEVICE_PREF_NONE;
+  devinfo->preferred = (strcmp(info->name, list_data->default_sink_name) == 0)
+                           ? CUBEB_DEVICE_PREF_ALL
+                           : CUBEB_DEVICE_PREF_NONE;
 
   devinfo->format = CUBEB_DEVICE_FMT_ALL;
-  devinfo->default_format = pulse_format_to_cubeb_format(info->sample_spec.format);
+  devinfo->default_format =
+      pulse_format_to_cubeb_format(info->sample_spec.format);
   devinfo->max_channels = info->channel_map.channels;
   devinfo->min_rate = 1;
   devinfo->max_rate = PA_RATE_MAX;
@@ -1339,8 +1384,8 @@ pulse_get_state_from_source_port(pa_source_port_info * info)
 }
 
 static void
-pulse_source_info_cb(pa_context * context, const pa_source_info * info,
-    int eol, void * user_data)
+pulse_source_info_cb(pa_context * context, const pa_source_info * info, int eol,
+                     void * user_data)
 {
   pulse_dev_list_data * list_data = user_data;
   cubeb_device_info * devinfo;
@@ -1365,7 +1410,7 @@ pulse_source_info_cb(pa_context * context, const pa_source_info * info,
   memset(devinfo, 0, sizeof(cubeb_device_info));
 
   devinfo->device_id = device_id;
-  devinfo->devid = (cubeb_devid) devinfo->device_id;
+  devinfo->devid = (cubeb_devid)devinfo->device_id;
   devinfo->friendly_name = strdup(info->description);
   prop = WRAP(pa_proplist_gets)(info->proplist, "sysfs.path");
   if (prop)
@@ -1376,11 +1421,13 @@ pulse_source_info_cb(pa_context * context, const pa_source_info * info,
 
   devinfo->type = CUBEB_DEVICE_TYPE_INPUT;
   devinfo->state = pulse_get_state_from_source_port(info->active_port);
-  devinfo->preferred = (strcmp(info->name, list_data->default_source_name) == 0) ?
-    CUBEB_DEVICE_PREF_ALL : CUBEB_DEVICE_PREF_NONE;
+  devinfo->preferred = (strcmp(info->name, list_data->default_source_name) == 0)
+                           ? CUBEB_DEVICE_PREF_ALL
+                           : CUBEB_DEVICE_PREF_NONE;
 
   devinfo->format = CUBEB_DEVICE_FMT_ALL;
-  devinfo->default_format = pulse_format_to_cubeb_format(info->sample_spec.format);
+  devinfo->default_format =
+      pulse_format_to_cubeb_format(info->sample_spec.format);
   devinfo->max_channels = info->channel_map.channels;
   devinfo->min_rate = 1;
   devinfo->max_rate = PA_RATE_MAX;
@@ -1402,9 +1449,9 @@ pulse_server_info_cb(pa_context * c, const pa_server_info * i, void * userdata)
   free(list_data->default_sink_name);
   free(list_data->default_source_name);
   list_data->default_sink_name =
-    i->default_sink_name ? strdup(i->default_sink_name) : NULL;
+      i->default_sink_name ? strdup(i->default_sink_name) : NULL;
   list_data->default_source_name =
-    i->default_source_name ? strdup(i->default_source_name) : NULL;
+      i->default_source_name ? strdup(i->default_source_name) : NULL;
 
   WRAP(pa_threaded_mainloop_signal)(list_data->context->mainloop, 0);
 }
@@ -1413,13 +1460,13 @@ static int
 pulse_enumerate_devices(cubeb * context, cubeb_device_type type,
                         cubeb_device_collection * collection)
 {
-  pulse_dev_list_data user_data = { NULL, NULL, NULL, 0, 0, context };
+  pulse_dev_list_data user_data = {NULL, NULL, NULL, 0, 0, context};
   pa_operation * o;
 
   WRAP(pa_threaded_mainloop_lock)(context->mainloop);
 
-  o = WRAP(pa_context_get_server_info)(context->context,
-      pulse_server_info_cb, &user_data);
+  o = WRAP(pa_context_get_server_info)(context->context, pulse_server_info_cb,
+                                       &user_data);
   if (o) {
     operation_wait(context, NULL, o);
     WRAP(pa_operation_unref)(o);
@@ -1427,7 +1474,7 @@ pulse_enumerate_devices(cubeb * context, cubeb_device_type type,
 
   if (type & CUBEB_DEVICE_TYPE_OUTPUT) {
     o = WRAP(pa_context_get_sink_info_list)(context->context,
-        pulse_sink_info_cb, &user_data);
+                                            pulse_sink_info_cb, &user_data);
     if (o) {
       operation_wait(context, NULL, o);
       WRAP(pa_operation_unref)(o);
@@ -1436,7 +1483,7 @@ pulse_enumerate_devices(cubeb * context, cubeb_device_type type,
 
   if (type & CUBEB_DEVICE_TYPE_INPUT) {
     o = WRAP(pa_context_get_source_info_list)(context->context,
-        pulse_source_info_cb, &user_data);
+                                              pulse_source_info_cb, &user_data);
     if (o) {
       operation_wait(context, NULL, o);
       WRAP(pa_operation_unref)(o);
@@ -1454,14 +1501,15 @@ pulse_enumerate_devices(cubeb * context, cubeb_device_type type,
 }
 
 static int
-pulse_device_collection_destroy(cubeb * ctx, cubeb_device_collection * collection)
+pulse_device_collection_destroy(cubeb * ctx,
+                                cubeb_device_collection * collection)
 {
   size_t n;
 
   for (n = 0; n < collection->count; n++) {
-    free((void *) collection->device[n].friendly_name);
-    free((void *) collection->device[n].vendor_name);
-    free((void *) collection->device[n].group_id);
+    free((void *)collection->device[n].friendly_name);
+    free((void *)collection->device[n].vendor_name);
+    free((void *)collection->device[n].group_id);
   }
 
   free(collection->device);
@@ -1469,7 +1517,8 @@ pulse_device_collection_destroy(cubeb * ctx, cubeb_device_collection * collectio
 }
 
 static int
-pulse_stream_get_current_device(cubeb_stream * stm, cubeb_device ** const device)
+pulse_stream_get_current_device(cubeb_stream * stm,
+                                cubeb_device ** const device)
 {
 #if PA_CHECK_VERSION(0, 9, 8)
   *device = calloc(1, sizeof(cubeb_device));
@@ -1493,8 +1542,7 @@ pulse_stream_get_current_device(cubeb_stream * stm, cubeb_device ** const device
 }
 
 static int
-pulse_stream_device_destroy(cubeb_stream * stream,
-                            cubeb_device * device)
+pulse_stream_device_destroy(cubeb_stream * stream, cubeb_device * device)
 {
   (void)stream;
   free(device->input_name);
@@ -1504,8 +1552,7 @@ pulse_stream_device_destroy(cubeb_stream * stream,
 }
 
 static void
-pulse_subscribe_callback(pa_context * ctx,
-                         pa_subscription_event_type_t t,
+pulse_subscribe_callback(pa_context * ctx, pa_subscription_event_type_t t,
                          uint32_t index, void * userdata)
 {
   (void)ctx;
@@ -1515,36 +1562,49 @@ pulse_subscribe_callback(pa_context * ctx,
   case PA_SUBSCRIPTION_EVENT_SERVER:
     if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_CHANGE) {
       LOG("Server changed %d", index);
-      WRAP(pa_context_get_server_info)(context->context, server_info_callback, context);
+      WRAP(pa_context_get_server_info)
+      (context->context, server_info_callback, context);
     }
     break;
   case PA_SUBSCRIPTION_EVENT_SOURCE:
   case PA_SUBSCRIPTION_EVENT_SINK:
 
     if (g_cubeb_log_level) {
-      if ((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_SOURCE &&
-          (t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
+      if ((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) ==
+              PA_SUBSCRIPTION_EVENT_SOURCE &&
+          (t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) ==
+              PA_SUBSCRIPTION_EVENT_REMOVE) {
         LOG("Removing source index %d", index);
-      } else if ((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_SOURCE &&
-          (t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
+      } else if ((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) ==
+                     PA_SUBSCRIPTION_EVENT_SOURCE &&
+                 (t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) ==
+                     PA_SUBSCRIPTION_EVENT_NEW) {
         LOG("Adding source index %d", index);
       }
-      if ((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_SINK &&
-          (t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
+      if ((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) ==
+              PA_SUBSCRIPTION_EVENT_SINK &&
+          (t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) ==
+              PA_SUBSCRIPTION_EVENT_REMOVE) {
         LOG("Removing sink index %d", index);
-      } else if ((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_SINK &&
-          (t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
+      } else if ((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) ==
+                     PA_SUBSCRIPTION_EVENT_SINK &&
+                 (t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) ==
+                     PA_SUBSCRIPTION_EVENT_NEW) {
         LOG("Adding sink index %d", index);
       }
     }
 
     if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE ||
         (t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
-      if ((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_SOURCE) {
-        context->input_collection_changed_callback(context, context->input_collection_changed_user_ptr);
+      if ((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) ==
+          PA_SUBSCRIPTION_EVENT_SOURCE) {
+        context->input_collection_changed_callback(
+            context, context->input_collection_changed_user_ptr);
       }
-      if ((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_SINK) {
-        context->output_collection_changed_callback(context, context->output_collection_changed_user_ptr);
+      if ((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) ==
+          PA_SUBSCRIPTION_EVENT_SINK) {
+        context->output_collection_changed_callback(
+            context, context->output_collection_changed_user_ptr);
       }
     }
     break;
@@ -1552,7 +1612,7 @@ pulse_subscribe_callback(pa_context * ctx,
 }
 
 static void
-subscribe_success(pa_context *c, int success, void *userdata)
+subscribe_success(pa_context * c, int success, void * userdata)
 {
   (void)c;
   cubeb * context = userdata;
@@ -1561,13 +1621,16 @@ subscribe_success(pa_context *c, int success, void *userdata)
 }
 
 static int
-pulse_subscribe_notifications(cubeb * context, pa_subscription_mask_t mask) {
+pulse_subscribe_notifications(cubeb * context, pa_subscription_mask_t mask)
+{
   WRAP(pa_threaded_mainloop_lock)(context->mainloop);
 
-  WRAP(pa_context_set_subscribe_callback)(context->context, pulse_subscribe_callback, context);
+  WRAP(pa_context_set_subscribe_callback)
+  (context->context, pulse_subscribe_callback, context);
 
   pa_operation * o;
-  o = WRAP(pa_context_subscribe)(context->context, mask, subscribe_success, context);
+  o = WRAP(pa_context_subscribe)(context->context, mask, subscribe_success,
+                                 context);
   if (o == NULL) {
     WRAP(pa_threaded_mainloop_unlock)(context->mainloop);
     LOG("Context subscribe failed");
@@ -1582,10 +1645,10 @@ pulse_subscribe_notifications(cubeb * context, pa_subscription_mask_t mask) {
 }
 
 static int
-pulse_register_device_collection_changed(cubeb * context,
-                                         cubeb_device_type devtype,
-                                         cubeb_device_collection_changed_callback collection_changed_callback,
-                                         void * user_ptr)
+pulse_register_device_collection_changed(
+    cubeb * context, cubeb_device_type devtype,
+    cubeb_device_collection_changed_callback collection_changed_callback,
+    void * user_ptr)
 {
   if (devtype & CUBEB_DEVICE_TYPE_INPUT) {
     context->input_collection_changed_callback = collection_changed_callback;
@@ -1613,25 +1676,25 @@ pulse_register_device_collection_changed(cubeb * context,
 }
 
 static struct cubeb_ops const pulse_ops = {
-  .init = pulse_init,
-  .get_backend_id = pulse_get_backend_id,
-  .get_max_channel_count = pulse_get_max_channel_count,
-  .get_min_latency = pulse_get_min_latency,
-  .get_preferred_sample_rate = pulse_get_preferred_sample_rate,
-  .enumerate_devices = pulse_enumerate_devices,
-  .device_collection_destroy = pulse_device_collection_destroy,
-  .destroy = pulse_destroy,
-  .stream_init = pulse_stream_init,
-  .stream_destroy = pulse_stream_destroy,
-  .stream_start = pulse_stream_start,
-  .stream_stop = pulse_stream_stop,
-  .stream_get_position = pulse_stream_get_position,
-  .stream_get_latency = pulse_stream_get_latency,
-  .stream_get_input_latency = NULL,
-  .stream_set_volume = pulse_stream_set_volume,
-  .stream_set_name = pulse_stream_set_name,
-  .stream_get_current_device = pulse_stream_get_current_device,
-  .stream_device_destroy = pulse_stream_device_destroy,
-  .stream_register_device_changed_callback = NULL,
-  .register_device_collection_changed = pulse_register_device_collection_changed
-};
+    .init = pulse_init,
+    .get_backend_id = pulse_get_backend_id,
+    .get_max_channel_count = pulse_get_max_channel_count,
+    .get_min_latency = pulse_get_min_latency,
+    .get_preferred_sample_rate = pulse_get_preferred_sample_rate,
+    .enumerate_devices = pulse_enumerate_devices,
+    .device_collection_destroy = pulse_device_collection_destroy,
+    .destroy = pulse_destroy,
+    .stream_init = pulse_stream_init,
+    .stream_destroy = pulse_stream_destroy,
+    .stream_start = pulse_stream_start,
+    .stream_stop = pulse_stream_stop,
+    .stream_get_position = pulse_stream_get_position,
+    .stream_get_latency = pulse_stream_get_latency,
+    .stream_get_input_latency = NULL,
+    .stream_set_volume = pulse_stream_set_volume,
+    .stream_set_name = pulse_stream_set_name,
+    .stream_get_current_device = pulse_stream_get_current_device,
+    .stream_device_destroy = pulse_stream_device_destroy,
+    .stream_register_device_changed_callback = NULL,
+    .register_device_collection_changed =
+        pulse_register_device_collection_changed};
diff --git a/src/cubeb_resampler.cpp b/src/cubeb_resampler.cpp
index b7bddfe..d61b1da 100644
--- a/src/cubeb_resampler.cpp
+++ b/src/cubeb_resampler.cpp
@@ -8,21 +8,21 @@
 #define NOMINMAX
 #endif // NOMINMAX
 
-#include <algorithm>
-#include <cmath>
-#include <cassert>
-#include <cstring>
-#include <cstddef>
-#include <cstdio>
 #include "cubeb_resampler.h"
 #include "cubeb-speex-resampler.h"
 #include "cubeb_resampler_internal.h"
 #include "cubeb_utils.h"
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <cstddef>
+#include <cstdio>
+#include <cstring>
 
 int
 to_speex_quality(cubeb_resampler_quality q)
 {
-  switch(q) {
+  switch (q) {
   case CUBEB_RESAMPLER_QUALITY_VOIP:
     return SPEEX_RESAMPLER_QUALITY_VOIP;
   case CUBEB_RESAMPLER_QUALITY_DEFAULT:
@@ -35,34 +35,34 @@ to_speex_quality(cubeb_resampler_quality q)
   }
 }
 
-uint32_t min_buffered_audio_frame(uint32_t sample_rate)
+uint32_t
+min_buffered_audio_frame(uint32_t sample_rate)
 {
   return sample_rate / 20;
 }
 
-template<typename T>
+template <typename T>
 passthrough_resampler<T>::passthrough_resampler(cubeb_stream * s,
                                                 cubeb_data_callback cb,
                                                 void * ptr,
                                                 uint32_t input_channels,
                                                 uint32_t sample_rate)
-  : processor(input_channels)
-  , stream(s)
-  , data_callback(cb)
-  , user_ptr(ptr)
-  , sample_rate(sample_rate)
+    : processor(input_channels), stream(s), data_callback(cb), user_ptr(ptr),
+      sample_rate(sample_rate)
 {
 }
 
-template<typename T>
-long passthrough_resampler<T>::fill(void * input_buffer, long * input_frames_count,
-                                    void * output_buffer, long output_frames)
+template <typename T>
+long
+passthrough_resampler<T>::fill(void * input_buffer, long * input_frames_count,
+                               void * output_buffer, long output_frames)
 {
   if (input_buffer) {
     assert(input_frames_count);
   }
   assert((input_buffer && output_buffer) ||
-         (output_buffer && !input_buffer && (!input_frames_count || *input_frames_count == 0)) ||
+         (output_buffer && !input_buffer &&
+          (!input_frames_count || *input_frames_count == 0)) ||
          (input_buffer && !output_buffer && output_frames == 0));
 
   // When we have no pending input data and exactly as much input
@@ -71,41 +71,44 @@ long passthrough_resampler<T>::fill(void * input_buffer, long * input_frames_cou
   void * in_buf = input_buffer;
   unsigned long pop_input_count = 0u;
   if (input_buffer && !output_buffer) {
-      output_frames = *input_frames_count;
-  } else if(input_buffer) {
+    output_frames = *input_frames_count;
+  } else if (input_buffer) {
     if (internal_input_buffer.length() != 0 ||
         *input_frames_count < output_frames) {
       // If we have pending input data left and have to first append the input
       // so we can pass it as one pointer to the callback. Or this is a glitch.
       // It can happen when system's performance is poor. Audible silence is
       // being pushed at the end of the short input buffer. An improvement for
-      // the future is to resample to the output number of frames, when that happens.
-      internal_input_buffer.push(static_cast<T*>(input_buffer),
+      // the future is to resample to the output number of frames, when that
+      // happens.
+      internal_input_buffer.push(static_cast<T *>(input_buffer),
                                  frames_to_samples(*input_frames_count));
       if (internal_input_buffer.length() < frames_to_samples(output_frames)) {
         // This is unxpected but it can happen when a glitch occurs. Fill the
         // buffer with silence. First keep the actual number of input samples
         // used without the silence.
         pop_input_count = internal_input_buffer.length();
-        internal_input_buffer.push_silence(
-            frames_to_samples(output_frames) - internal_input_buffer.length());
+        internal_input_buffer.push_silence(frames_to_samples(output_frames) -
+                                           internal_input_buffer.length());
       } else {
         pop_input_count = frames_to_samples(output_frames);
       }
       in_buf = internal_input_buffer.data();
-    } else if(*input_frames_count > output_frames) {
+    } else if (*input_frames_count > output_frames) {
       // In this case we have more input that we need output and
       // fill the overflowing input into internal_input_buffer
       // Since we have no other pending data, we can nonetheless
       // pass the current input data directly to the callback
       assert(pop_input_count == 0);
       unsigned long samples_off = frames_to_samples(output_frames);
-      internal_input_buffer.push(static_cast<T*>(input_buffer) + samples_off,
-                                 frames_to_samples(*input_frames_count - output_frames));
+      internal_input_buffer.push(
+          static_cast<T *>(input_buffer) + samples_off,
+          frames_to_samples(*input_frames_count - output_frames));
     }
   }
 
-  long rv = data_callback(stream, user_ptr, in_buf, output_buffer, output_frames);
+  long rv =
+      data_callback(stream, user_ptr, in_buf, output_buffer, output_frames);
 
   if (input_buffer) {
     if (pop_input_count) {
@@ -124,51 +127,47 @@ long passthrough_resampler<T>::fill(void * input_buffer, long * input_frames_cou
 template class passthrough_resampler<float>;
 template class passthrough_resampler<short>;
 
-template<typename T, typename InputProcessor, typename OutputProcessor>
-cubeb_resampler_speex<T, InputProcessor, OutputProcessor>
-  ::cubeb_resampler_speex(InputProcessor * input_processor,
-                          OutputProcessor * output_processor,
-                          cubeb_stream * s,
-                          cubeb_data_callback cb,
-                          void * ptr)
-  : input_processor(input_processor)
-  , output_processor(output_processor)
-  , stream(s)
-  , data_callback(cb)
-  , user_ptr(ptr)
+template <typename T, typename InputProcessor, typename OutputProcessor>
+cubeb_resampler_speex<T, InputProcessor, OutputProcessor>::
+    cubeb_resampler_speex(InputProcessor * input_processor,
+                          OutputProcessor * output_processor, cubeb_stream * s,
+                          cubeb_data_callback cb, void * ptr)
+    : input_processor(input_processor), output_processor(output_processor),
+      stream(s), data_callback(cb), user_ptr(ptr)
 {
   if (input_processor && output_processor) {
     fill_internal = &cubeb_resampler_speex::fill_internal_duplex;
-  }  else if (input_processor) {
+  } else if (input_processor) {
     fill_internal = &cubeb_resampler_speex::fill_internal_input;
-  }  else if (output_processor) {
+  } else if (output_processor) {
     fill_internal = &cubeb_resampler_speex::fill_internal_output;
   }
 }
 
-template<typename T, typename InputProcessor, typename OutputProcessor>
-cubeb_resampler_speex<T, InputProcessor, OutputProcessor>
-  ::~cubeb_resampler_speex()
-{ }
+template <typename T, typename InputProcessor, typename OutputProcessor>
+cubeb_resampler_speex<T, InputProcessor,
+                      OutputProcessor>::~cubeb_resampler_speex()
+{
+}
 
-template<typename T, typename InputProcessor, typename OutputProcessor>
+template <typename T, typename InputProcessor, typename OutputProcessor>
 long
-cubeb_resampler_speex<T, InputProcessor, OutputProcessor>
-::fill(void * input_buffer, long * input_frames_count,
-       void * output_buffer, long output_frames_needed)
+cubeb_resampler_speex<T, InputProcessor, OutputProcessor>::fill(
+    void * input_buffer, long * input_frames_count, void * output_buffer,
+    long output_frames_needed)
 {
   /* Input and output buffers, typed */
-  T * in_buffer = reinterpret_cast<T*>(input_buffer);
-  T * out_buffer = reinterpret_cast<T*>(output_buffer);
-  return (this->*fill_internal)(in_buffer, input_frames_count,
-                                out_buffer, output_frames_needed);
+  T * in_buffer = reinterpret_cast<T *>(input_buffer);
+  T * out_buffer = reinterpret_cast<T *>(output_buffer);
+  return (this->*fill_internal)(in_buffer, input_frames_count, out_buffer,
+                                output_frames_needed);
 }
 
-template<typename T, typename InputProcessor, typename OutputProcessor>
+template <typename T, typename InputProcessor, typename OutputProcessor>
 long
-cubeb_resampler_speex<T, InputProcessor, OutputProcessor>
-::fill_internal_output(T * input_buffer, long * input_frames_count,
-                       T * output_buffer, long output_frames_needed)
+cubeb_resampler_speex<T, InputProcessor, OutputProcessor>::fill_internal_output(
+    T * input_buffer, long * input_frames_count, T * output_buffer,
+    long output_frames_needed)
 {
   assert(!input_buffer && (!input_frames_count || *input_frames_count == 0) &&
          output_buffer && output_frames_needed);
@@ -180,13 +179,12 @@ cubeb_resampler_speex<T, InputProcessor, OutputProcessor>
 
     /* fill directly the input buffer of the output processor to save a copy */
     output_frames_before_processing =
-      output_processor->input_needed_for_output(output_frames_needed);
+        output_processor->input_needed_for_output(output_frames_needed);
 
     out_unprocessed =
-      output_processor->input_buffer(output_frames_before_processing);
+        output_processor->input_buffer(output_frames_before_processing);
 
-    got = data_callback(stream, user_ptr,
-                        nullptr, out_unprocessed,
+    got = data_callback(stream, user_ptr, nullptr, out_unprocessed,
                         output_frames_before_processing);
 
     if (got < output_frames_before_processing) {
@@ -201,58 +199,62 @@ cubeb_resampler_speex<T, InputProcessor, OutputProcessor>
   }
 
   /* Process the output. If not enough frames have been returned from the
-  * callback, drain the processors. */
+   * callback, drain the processors. */
   return output_processor->output(output_buffer, output_frames_needed);
 }
 
-template<typename T, typename InputProcessor, typename OutputProcessor>
+template <typename T, typename InputProcessor, typename OutputProcessor>
 long
-cubeb_resampler_speex<T, InputProcessor, OutputProcessor>
-::fill_internal_input(T * input_buffer, long * input_frames_count,
-                      T * output_buffer, long /*output_frames_needed*/)
+cubeb_resampler_speex<T, InputProcessor, OutputProcessor>::fill_internal_input(
+    T * input_buffer, long * input_frames_count, T * output_buffer,
+    long /*output_frames_needed*/)
 {
   assert(input_buffer && input_frames_count && *input_frames_count &&
          !output_buffer);
 
-  /* The input data, after eventual resampling. This is passed to the callback. */
+  /* The input data, after eventual resampling. This is passed to the callback.
+   */
   T * resampled_input = nullptr;
-  uint32_t resampled_frame_count = input_processor->output_for_input(*input_frames_count);
+  uint32_t resampled_frame_count =
+      input_processor->output_for_input(*input_frames_count);
 
   /* process the input, and present exactly `output_frames_needed` in the
-  * callback. */
+   * callback. */
   input_processor->input(input_buffer, *input_frames_count);
 
   /* resampled_frame_count == 0 happens if the resampler
    * doesn't have enough input frames buffered to produce 1 resampled frame. */
   if (resampled_frame_count == 0) {
-      return *input_frames_count;
+    return *input_frames_count;
   }
 
   size_t frames_resampled = 0;
-  resampled_input = input_processor->output(resampled_frame_count, &frames_resampled);
+  resampled_input =
+      input_processor->output(resampled_frame_count, &frames_resampled);
   *input_frames_count = frames_resampled;
 
-  long got = data_callback(stream, user_ptr,
-                           resampled_input, nullptr, resampled_frame_count);
+  long got = data_callback(stream, user_ptr, resampled_input, nullptr,
+                           resampled_frame_count);
 
   /* Return the number of initial input frames or part of it.
-  * Since output_frames_needed == 0 in input scenario, the only
-  * available number outside resampler is the initial number of frames. */
+   * Since output_frames_needed == 0 in input scenario, the only
+   * available number outside resampler is the initial number of frames. */
   return (*input_frames_count) * (got / resampled_frame_count);
 }
 
-template<typename T, typename InputProcessor, typename OutputProcessor>
+template <typename T, typename InputProcessor, typename OutputProcessor>
 long
-cubeb_resampler_speex<T, InputProcessor, OutputProcessor>
-::fill_internal_duplex(T * in_buffer, long * input_frames_count,
-                       T * out_buffer, long output_frames_needed)
+cubeb_resampler_speex<T, InputProcessor, OutputProcessor>::fill_internal_duplex(
+    T * in_buffer, long * input_frames_count, T * out_buffer,
+    long output_frames_needed)
 {
   if (draining) {
     // discard input and drain any signal remaining in the resampler.
     return output_processor->output(out_buffer, output_frames_needed);
   }
 
-  /* The input data, after eventual resampling. This is passed to the callback. */
+  /* The input data, after eventual resampling. This is passed to the callback.
+   */
   T * resampled_input = nullptr;
   /* The output buffer passed down in the callback, that might be resampled. */
   T * out_unprocessed = nullptr;
@@ -272,26 +274,25 @@ cubeb_resampler_speex<T, InputProcessor, OutputProcessor>
    * caller. */
 
   output_frames_before_processing =
-    output_processor->input_needed_for_output(output_frames_needed);
-   /* fill directly the input buffer of the output processor to save a copy */
+      output_processor->input_needed_for_output(output_frames_needed);
+  /* fill directly the input buffer of the output processor to save a copy */
   out_unprocessed =
-    output_processor->input_buffer(output_frames_before_processing);
+      output_processor->input_buffer(output_frames_before_processing);
 
   if (in_buffer) {
     /* process the input, and present exactly `output_frames_needed` in the
-    * callback. */
+     * callback. */
     input_processor->input(in_buffer, *input_frames_count);
 
     size_t frames_resampled = 0;
-    resampled_input =
-      input_processor->output(output_frames_before_processing, &frames_resampled);
+    resampled_input = input_processor->output(output_frames_before_processing,
+                                              &frames_resampled);
     *input_frames_count = frames_resampled;
   } else {
     resampled_input = nullptr;
   }
 
-  got = data_callback(stream, user_ptr,
-                      resampled_input, out_unprocessed,
+  got = data_callback(stream, user_ptr, resampled_input, out_unprocessed,
                       output_frames_before_processing);
 
   if (got < output_frames_before_processing) {
@@ -321,10 +322,8 @@ cubeb_resampler *
 cubeb_resampler_create(cubeb_stream * stream,
                        cubeb_stream_params * input_params,
                        cubeb_stream_params * output_params,
-                       unsigned int target_rate,
-                       cubeb_data_callback callback,
-                       void * user_ptr,
-                       cubeb_resampler_quality quality)
+                       unsigned int target_rate, cubeb_data_callback callback,
+                       void * user_ptr, cubeb_resampler_quality quality)
 {
   cubeb_sample_format format;
 
@@ -336,38 +335,28 @@ cubeb_resampler_create(cubeb_stream * stream,
     format = output_params->format;
   }
 
-  switch(format) {
-    case CUBEB_SAMPLE_S16NE:
-      return cubeb_resampler_create_internal<short>(stream,
-                                                    input_params,
-                                                    output_params,
-                                                    target_rate,
-                                                    callback,
-                                                    user_ptr,
-                                                    quality);
-    case CUBEB_SAMPLE_FLOAT32NE:
-      return cubeb_resampler_create_internal<float>(stream,
-                                                    input_params,
-                                                    output_params,
-                                                    target_rate,
-                                                    callback,
-                                                    user_ptr,
-                                                    quality);
-    default:
-      assert(false);
-      return nullptr;
+  switch (format) {
+  case CUBEB_SAMPLE_S16NE:
+    return cubeb_resampler_create_internal<short>(stream, input_params,
+                                                  output_params, target_rate,
+                                                  callback, user_ptr, quality);
+  case CUBEB_SAMPLE_FLOAT32NE:
+    return cubeb_resampler_create_internal<float>(stream, input_params,
+                                                  output_params, target_rate,
+                                                  callback, user_ptr, quality);
+  default:
+    assert(false);
+    return nullptr;
   }
 }
 
 long
-cubeb_resampler_fill(cubeb_resampler * resampler,
-                     void * input_buffer,
-                     long * input_frames_count,
-                     void * output_buffer,
+cubeb_resampler_fill(cubeb_resampler * resampler, void * input_buffer,
+                     long * input_frames_count, void * output_buffer,
                      long output_frames_needed)
 {
-  return resampler->fill(input_buffer, input_frames_count,
-                         output_buffer, output_frames_needed);
+  return resampler->fill(input_buffer, input_frames_count, output_buffer,
+                         output_frames_needed);
 }
 
 void
diff --git a/src/cubeb_resampler.h b/src/cubeb_resampler.h
index f6b5513..e9b9532 100644
--- a/src/cubeb_resampler.h
+++ b/src/cubeb_resampler.h
@@ -39,13 +39,12 @@ typedef enum {
  * @param quality Quality of the resampler.
  * @retval A non-null pointer if success.
  */
-cubeb_resampler * cubeb_resampler_create(cubeb_stream * stream,
-                                         cubeb_stream_params * input_params,
-                                         cubeb_stream_params * output_params,
-                                         unsigned int target_rate,
-                                         cubeb_data_callback callback,
-                                         void * user_ptr,
-                                         cubeb_resampler_quality quality);
+cubeb_resampler *
+cubeb_resampler_create(cubeb_stream * stream,
+                       cubeb_stream_params * input_params,
+                       cubeb_stream_params * output_params,
+                       unsigned int target_rate, cubeb_data_callback callback,
+                       void * user_ptr, cubeb_resampler_quality quality);
 
 /**
  * Fill the buffer with frames acquired using the data callback. Resampling will
@@ -59,24 +58,25 @@ cubeb_resampler * cubeb_resampler_create(cubeb_stream * stream,
  * @retval Number of frames that are actually produced.
  * @retval CUBEB_ERROR on error.
  */
-long cubeb_resampler_fill(cubeb_resampler * resampler,
-                          void * input_buffer,
-                          long * input_frame_count,
-                          void * output_buffer,
-                          long output_frames_needed);
+long
+cubeb_resampler_fill(cubeb_resampler * resampler, void * input_buffer,
+                     long * input_frame_count, void * output_buffer,
+                     long output_frames_needed);
 
 /**
  * Destroy a cubeb_resampler.
  * @param resampler A cubeb_resampler instance.
  */
-void cubeb_resampler_destroy(cubeb_resampler * resampler);
+void
+cubeb_resampler_destroy(cubeb_resampler * resampler);
 
 /**
  * Returns the latency, in frames, of the resampler.
  * @param resampler A cubeb resampler instance.
  * @retval The latency, in frames, induced by the resampler.
  */
-long cubeb_resampler_latency(cubeb_resampler * resampler);
+long
+cubeb_resampler_latency(cubeb_resampler * resampler);
 
 #if defined(__cplusplus)
 }
diff --git a/src/cubeb_resampler_internal.h b/src/cubeb_resampler_internal.h
index ed56857..2eabb7c 100644
--- a/src/cubeb_resampler_internal.h
+++ b/src/cubeb_resampler_internal.h
@@ -8,9 +8,9 @@
 #if !defined(CUBEB_RESAMPLER_INTERNAL)
 #define CUBEB_RESAMPLER_INTERNAL
 
-#include <cmath>
-#include <cassert>
 #include <algorithm>
+#include <cassert>
+#include <cmath>
 #include <memory>
 #ifdef CUBEB_GECKO_BUILD
 #include "mozilla/UniquePtr.h"
@@ -25,29 +25,32 @@
 #define MOZ_END_STD_NAMESPACE }
 #endif
 MOZ_BEGIN_STD_NAMESPACE
-  using mozilla::DefaultDelete;
-  using mozilla::UniquePtr;
-  #define default_delete DefaultDelete
-  #define unique_ptr UniquePtr
+using mozilla::DefaultDelete;
+using mozilla::UniquePtr;
+#define default_delete DefaultDelete
+#define unique_ptr UniquePtr
 MOZ_END_STD_NAMESPACE
 #endif
-#include "cubeb/cubeb.h"
-#include "cubeb_utils.h"
 #include "cubeb-speex-resampler.h"
-#include "cubeb_resampler.h"
+#include "cubeb/cubeb.h"
 #include "cubeb_log.h"
+#include "cubeb_resampler.h"
+#include "cubeb_utils.h"
 #include <stdio.h>
 
-/* This header file contains the internal C++ API of the resamplers, for testing. */
+/* This header file contains the internal C++ API of the resamplers, for
+ * testing. */
 
 // When dropping audio input frames to prevent building
 // an input delay, this function returns the number of frames
 // to keep in the buffer.
 // @parameter sample_rate The sample rate of the stream.
 // @return A number of frames to keep.
-uint32_t min_buffered_audio_frame(uint32_t sample_rate);
+uint32_t
+min_buffered_audio_frame(uint32_t sample_rate);
 
-int to_speex_quality(cubeb_resampler_quality q);
+int
+to_speex_quality(cubeb_resampler_quality q);
 
 struct cubeb_resampler {
   virtual long fill(void * input_buffer, long * input_frames_count,
@@ -59,14 +62,10 @@ struct cubeb_resampler {
 /** Base class for processors. This is just used to share methods for now. */
 class processor {
 public:
-  explicit processor(uint32_t channels)
-    : channels(channels)
-  {}
+  explicit processor(uint32_t channels) : channels(channels) {}
+
 protected:
-  size_t frames_to_samples(size_t frames) const
-  {
-    return frames * channels;
-  }
+  size_t frames_to_samples(size_t frames) const { return frames * channels; }
   size_t samples_to_frames(size_t samples) const
   {
     assert(!(samples % channels));
@@ -76,30 +75,24 @@ protected:
   const uint32_t channels;
 };
 
-template<typename T>
-class passthrough_resampler : public cubeb_resampler
-                            , public processor {
+template <typename T>
+class passthrough_resampler : public cubeb_resampler, public processor {
 public:
-  passthrough_resampler(cubeb_stream * s,
-                        cubeb_data_callback cb,
-                        void * ptr,
-                        uint32_t input_channels,
-                        uint32_t sample_rate);
+  passthrough_resampler(cubeb_stream * s, cubeb_data_callback cb, void * ptr,
+                        uint32_t input_channels, uint32_t sample_rate);
 
   virtual long fill(void * input_buffer, long * input_frames_count,
                     void * output_buffer, long output_frames);
 
-  virtual long latency()
-  {
-    return 0;
-  }
+  virtual long latency() { return 0; }
 
   void drop_audio_if_needed()
   {
     uint32_t to_keep = min_buffered_audio_frame(sample_rate);
     uint32_t available = samples_to_frames(internal_input_buffer.length());
     if (available > to_keep) {
-      internal_input_buffer.pop(nullptr, frames_to_samples(available - to_keep));
+      internal_input_buffer.pop(nullptr,
+                                frames_to_samples(available - to_keep));
     }
   }
 
@@ -116,14 +109,12 @@ private:
 /** Bidirectional resampler, can resample an input and an output stream, or just
  * an input stream or output stream. In this case a delay is inserted in the
  * opposite direction to keep the streams synchronized. */
-template<typename T, typename InputProcessing, typename OutputProcessing>
+template <typename T, typename InputProcessing, typename OutputProcessing>
 class cubeb_resampler_speex : public cubeb_resampler {
 public:
   cubeb_resampler_speex(InputProcessing * input_processor,
-                        OutputProcessing * output_processor,
-                        cubeb_stream * s,
-                        cubeb_data_callback cb,
-                        void * ptr);
+                        OutputProcessing * output_processor, cubeb_stream * s,
+                        cubeb_data_callback cb, void * ptr);
 
   virtual ~cubeb_resampler_speex();
 
@@ -143,7 +134,9 @@ public:
   }
 
 private:
-  typedef long(cubeb_resampler_speex::*processing_callback)(T * input_buffer, long * input_frames_count, T * output_buffer, long output_frames_needed);
+  typedef long (cubeb_resampler_speex::*processing_callback)(
+      T * input_buffer, long * input_frames_count, T * output_buffer,
+      long output_frames_needed);
 
   long fill_internal_duplex(T * input_buffer, long * input_frames_count,
                             T * output_buffer, long output_frames_needed);
@@ -165,8 +158,7 @@ private:
  * audio buffers of type T. This class is designed so that the number of frames
  * coming out of the resampler can be precisely controled. It manages its own
  * input buffer, and can use the caller's output buffer, or allocate its own. */
-template<typename T>
-class cubeb_resampler_speex_one_way : public processor {
+template <typename T> class cubeb_resampler_speex_one_way : public processor {
 public:
   /** The sample type of this resampler, either 16-bit integers or 32-bit
    * floats. */
@@ -178,19 +170,15 @@ public:
    * @parameter target_rate The sample-rate of the audio output.
    * @parameter quality A number between 0 (fast, low quality) and 10 (slow,
    * high quality). */
-  cubeb_resampler_speex_one_way(uint32_t channels,
-                                uint32_t source_rate,
-                                uint32_t target_rate,
-                                int quality)
-  : processor(channels)
-  , resampling_ratio(static_cast<float>(source_rate) / target_rate)
-  , source_rate(source_rate)
-  , additional_latency(0)
-  , leftover_samples(0)
+  cubeb_resampler_speex_one_way(uint32_t channels, uint32_t source_rate,
+                                uint32_t target_rate, int quality)
+      : processor(channels),
+        resampling_ratio(static_cast<float>(source_rate) / target_rate),
+        source_rate(source_rate), additional_latency(0), leftover_samples(0)
   {
     int r;
-    speex_resampler = speex_resampler_init(channels, source_rate,
-                                           target_rate, quality, &r);
+    speex_resampler =
+        speex_resampler_init(channels, source_rate, target_rate, quality, &r);
     assert(r == RESAMPLER_ERR_SUCCESS && "resampler allocation failure");
 
     uint32_t input_latency = speex_resampler_get_input_latency(speex_resampler);
@@ -200,11 +188,8 @@ public:
     uint32_t input_frame_count = input_latency;
     uint32_t output_frame_count = LATENCY_SAMPLES;
     assert(input_latency * channels <= LATENCY_SAMPLES);
-    speex_resample(
-      input_buffer,
-      &input_frame_count,
-      output_buffer,
-      &output_frame_count);
+    speex_resample(input_buffer, &input_frame_count, output_buffer,
+                   &output_frame_count);
   }
 
   /** Destructor, deallocate the resampler */
@@ -221,14 +206,14 @@ public:
   }
 
   /** Outputs exactly `output_frame_count` into `output_buffer`.
-    * `output_buffer` has to be at least `output_frame_count` long. */
+   * `output_buffer` has to be at least `output_frame_count` long. */
   size_t output(T * output_buffer, size_t output_frame_count)
   {
     uint32_t in_len = samples_to_frames(resampling_in_buffer.length());
     uint32_t out_len = output_frame_count;
 
-    speex_resample(resampling_in_buffer.data(), &in_len,
-                   output_buffer, &out_len);
+    speex_resample(resampling_in_buffer.data(), &in_len, output_buffer,
+                   &out_len);
 
     /* This shifts back any unresampled samples to the beginning of the input
        buffer. */
@@ -239,15 +224,17 @@ public:
 
   size_t output_for_input(uint32_t input_frames)
   {
-    return (size_t)floorf((input_frames + samples_to_frames(resampling_in_buffer.length()))
-                         / resampling_ratio);
+    return (size_t)floorf(
+        (input_frames + samples_to_frames(resampling_in_buffer.length())) /
+        resampling_ratio);
   }
 
   /** Returns a buffer containing exactly `output_frame_count` resampled frames.
-    * The consumer should not hold onto the pointer. */
+   * The consumer should not hold onto the pointer. */
   T * output(size_t output_frame_count, size_t * input_frames_used)
   {
-    if (resampling_out_buffer.capacity() < frames_to_samples(output_frame_count)) {
+    if (resampling_out_buffer.capacity() <
+        frames_to_samples(output_frame_count)) {
       resampling_out_buffer.reserve(frames_to_samples(output_frame_count));
     }
 
@@ -258,10 +245,12 @@ public:
                    resampling_out_buffer.data(), &out_len);
 
     if (out_len < output_frame_count) {
-      LOGV("underrun during resampling: got %u frames, expected %zu", (unsigned)out_len, output_frame_count);
+      LOGV("underrun during resampling: got %u frames, expected %zu",
+           (unsigned)out_len, output_frame_count);
       // silence the rightmost part
-      T* data = resampling_out_buffer.data();
-      for (uint32_t i = frames_to_samples(out_len); i < frames_to_samples(output_frame_count); i++) {
+      T * data = resampling_out_buffer.data();
+      for (uint32_t i = frames_to_samples(out_len);
+           i < frames_to_samples(output_frame_count); i++) {
         data[i] = 0;
       }
     }
@@ -281,8 +270,8 @@ public:
      * only consider a single channel here so it's the same number of frames. */
     int latency = 0;
 
-    latency =
-      speex_resampler_get_output_latency(speex_resampler) + additional_latency;
+    latency = speex_resampler_get_output_latency(speex_resampler) +
+              additional_latency;
 
     assert(latency >= 0);
 
@@ -296,11 +285,13 @@ public:
   uint32_t input_needed_for_output(int32_t output_frame_count) const
   {
     assert(output_frame_count >= 0); // Check overflow
-    int32_t unresampled_frames_left = samples_to_frames(resampling_in_buffer.length());
-    int32_t resampled_frames_left = samples_to_frames(resampling_out_buffer.length());
+    int32_t unresampled_frames_left =
+        samples_to_frames(resampling_in_buffer.length());
+    int32_t resampled_frames_left =
+        samples_to_frames(resampling_out_buffer.length());
     float input_frames_needed =
-      (output_frame_count - unresampled_frames_left) * resampling_ratio
-        - resampled_frames_left;
+        (output_frame_count - unresampled_frames_left) * resampling_ratio -
+        resampled_frames_left;
     if (input_frames_needed < 0) {
       return 0;
     }
@@ -337,9 +328,10 @@ public:
       resampling_in_buffer.pop(nullptr, frames_to_samples(available - to_keep));
     }
   }
+
 private:
   /** Wrapper for the speex resampling functions to have a typed
-    * interface. */
+   * interface. */
   void speex_resample(float * input_buffer, uint32_t * input_frame_count,
                       float * output_buffer, uint32_t * output_frame_count)
   {
@@ -347,11 +339,9 @@ private:
     int rv;
     rv =
 #endif
-      speex_resampler_process_interleaved_float(speex_resampler,
-                                                input_buffer,
-                                                input_frame_count,
-                                                output_buffer,
-                                                output_frame_count);
+        speex_resampler_process_interleaved_float(
+            speex_resampler, input_buffer, input_frame_count, output_buffer,
+            output_frame_count);
     assert(rv == RESAMPLER_ERR_SUCCESS);
   }
 
@@ -362,11 +352,9 @@ private:
     int rv;
     rv =
 #endif
-      speex_resampler_process_interleaved_int(speex_resampler,
-                                              input_buffer,
-                                              input_frame_count,
-                                              output_buffer,
-                                              output_frame_count);
+        speex_resampler_process_interleaved_int(
+            speex_resampler, input_buffer, input_frame_count, output_buffer,
+            output_frame_count);
     assert(rv == RESAMPLER_ERR_SUCCESS);
   }
   /** The state for the speex resampler used internaly. */
@@ -387,18 +375,16 @@ private:
 };
 
 /** This class allows delaying an audio stream by `frames` frames. */
-template<typename T>
-class delay_line : public processor {
+template <typename T> class delay_line : public processor {
 public:
   /** Constructor
    * @parameter frames the number of frames of delay.
    * @parameter channels the number of channels of this delay line.
-   * @parameter sample_rate sample-rate of the audio going through this delay line */
+   * @parameter sample_rate sample-rate of the audio going through this delay
+   * line */
   delay_line(uint32_t frames, uint32_t channels, uint32_t sample_rate)
-    : processor(channels)
-    , length(frames)
-    , leftover_samples(0)
-    , sample_rate(sample_rate)
+      : processor(channels), length(frames), leftover_samples(0),
+        sample_rate(sample_rate)
   {
     /* Fill the delay line with some silent frames to add latency. */
     delay_input_buffer.push_silence(frames * channels);
@@ -436,7 +422,8 @@ public:
   T * input_buffer(uint32_t frames_needed)
   {
     leftover_samples = delay_input_buffer.length();
-    delay_input_buffer.reserve(leftover_samples + frames_to_samples(frames_needed));
+    delay_input_buffer.reserve(leftover_samples +
+                               frames_to_samples(frames_needed));
     return delay_input_buffer.data() + leftover_samples;
   }
   /** This method works with `input_buffer`, and allows to inform the processor
@@ -471,17 +458,12 @@ public:
     assert(frames_needed >= 0); // Check overflow
     return frames_needed;
   }
-  /** Returns the number of frames produces for `input_frames` frames in input */
-  size_t output_for_input(uint32_t input_frames)
-  {
-    return input_frames;
-  }
+  /** Returns the number of frames produces for `input_frames` frames in input
+   */
+  size_t output_for_input(uint32_t input_frames) { return input_frames; }
   /** The number of frames this delay line delays the stream by.
    * @returns The number of frames of delay. */
-  size_t latency()
-  {
-    return length;
-  }
+  size_t latency() { return length; }
 
   void drop_audio_if_needed()
   {
@@ -491,6 +473,7 @@ public:
       delay_input_buffer.pop(nullptr, frames_to_samples(available - to_keep));
     }
   }
+
 private:
   /** The length, in frames, of this delay line */
   uint32_t length;
@@ -506,14 +489,13 @@ private:
 };
 
 /** This sits behind the C API and is more typed. */
-template<typename T>
+template <typename T>
 cubeb_resampler *
 cubeb_resampler_create_internal(cubeb_stream * stream,
                                 cubeb_stream_params * input_params,
                                 cubeb_stream_params * output_params,
                                 unsigned int target_rate,
-                                cubeb_data_callback callback,
-                                void * user_ptr,
+                                cubeb_data_callback callback, void * user_ptr,
                                 cubeb_resampler_quality quality)
 {
   std::unique_ptr<cubeb_resampler_speex_one_way<T>> input_resampler = nullptr;
@@ -528,35 +510,31 @@ cubeb_resampler_create_internal(cubeb_stream * stream,
      sample rate, use a no-op resampler, that simply forwards the buffers to the
      callback. */
   if (((input_params && input_params->rate == target_rate) &&
-      (output_params && output_params->rate == target_rate)) ||
+       (output_params && output_params->rate == target_rate)) ||
       (input_params && !output_params && (input_params->rate == target_rate)) ||
-      (output_params && !input_params && (output_params->rate == target_rate))) {
+      (output_params && !input_params &&
+       (output_params->rate == target_rate))) {
     LOG("Input and output sample-rate match, target rate of %dHz", target_rate);
-    return new passthrough_resampler<T>(stream, callback,
-                                        user_ptr,
-                                        input_params ? input_params->channels : 0,
-                                        target_rate);
+    return new passthrough_resampler<T>(
+        stream, callback, user_ptr, input_params ? input_params->channels : 0,
+        target_rate);
   }
 
   /* Determine if we need to resampler one or both directions, and create the
      resamplers. */
   if (output_params && (output_params->rate != target_rate)) {
-    output_resampler.reset(
-        new cubeb_resampler_speex_one_way<T>(output_params->channels,
-                                             target_rate,
-                                             output_params->rate,
-                                             to_speex_quality(quality)));
+    output_resampler.reset(new cubeb_resampler_speex_one_way<T>(
+        output_params->channels, target_rate, output_params->rate,
+        to_speex_quality(quality)));
     if (!output_resampler) {
       return NULL;
     }
   }
 
   if (input_params && (input_params->rate != target_rate)) {
-    input_resampler.reset(
-        new cubeb_resampler_speex_one_way<T>(input_params->channels,
-                                             input_params->rate,
-                                             target_rate,
-                                             to_speex_quality(quality)));
+    input_resampler.reset(new cubeb_resampler_speex_one_way<T>(
+        input_params->channels, input_params->rate, target_rate,
+        to_speex_quality(quality)));
     if (!input_resampler) {
       return NULL;
     }
@@ -572,7 +550,8 @@ cubeb_resampler_create_internal(cubeb_stream * stream,
     if (!output_delay) {
       return NULL;
     }
-  } else if (output_resampler && !input_resampler && input_params && output_params) {
+  } else if (output_resampler && !input_resampler && input_params &&
+             output_params) {
     input_delay.reset(new delay_line<T>(output_resampler->latency(),
                                         input_params->channels,
                                         output_params->rate));
@@ -582,29 +561,26 @@ cubeb_resampler_create_internal(cubeb_stream * stream,
   }
 
   if (input_resampler && output_resampler) {
-    LOG("Resampling input (%d) and output (%d) to target rate of %dHz", input_params->rate, output_params->rate, target_rate);
-    return new cubeb_resampler_speex<T,
-                                     cubeb_resampler_speex_one_way<T>,
-                                     cubeb_resampler_speex_one_way<T>>
-                                       (input_resampler.release(),
-                                        output_resampler.release(),
-                                        stream, callback, user_ptr);
+    LOG("Resampling input (%d) and output (%d) to target rate of %dHz",
+        input_params->rate, output_params->rate, target_rate);
+    return new cubeb_resampler_speex<T, cubeb_resampler_speex_one_way<T>,
+                                     cubeb_resampler_speex_one_way<T>>(
+        input_resampler.release(), output_resampler.release(), stream, callback,
+        user_ptr);
   } else if (input_resampler) {
-    LOG("Resampling input (%d) to target and output rate of %dHz", input_params->rate, target_rate);
-    return new cubeb_resampler_speex<T,
-                                     cubeb_resampler_speex_one_way<T>,
-                                     delay_line<T>>
-                                      (input_resampler.release(),
-                                       output_delay.release(),
-                                       stream, callback, user_ptr);
+    LOG("Resampling input (%d) to target and output rate of %dHz",
+        input_params->rate, target_rate);
+    return new cubeb_resampler_speex<T, cubeb_resampler_speex_one_way<T>,
+                                     delay_line<T>>(input_resampler.release(),
+                                                    output_delay.release(),
+                                                    stream, callback, user_ptr);
   } else {
-    LOG("Resampling output (%dHz) to target and input rate of %dHz", output_params->rate, target_rate);
-    return new cubeb_resampler_speex<T,
-                                     delay_line<T>,
-                                     cubeb_resampler_speex_one_way<T>>
-                                      (input_delay.release(),
-                                       output_resampler.release(),
-                                       stream, callback, user_ptr);
+    LOG("Resampling output (%dHz) to target and input rate of %dHz",
+        output_params->rate, target_rate);
+    return new cubeb_resampler_speex<T, delay_line<T>,
+                                     cubeb_resampler_speex_one_way<T>>(
+        input_delay.release(), output_resampler.release(), stream, callback,
+        user_ptr);
   }
 }
 
diff --git a/src/cubeb_ring_array.h b/src/cubeb_ring_array.h
index 51b3b32..05a8fe9 100644
--- a/src/cubeb_ring_array.h
+++ b/src/cubeb_ring_array.h
@@ -16,17 +16,16 @@
     them in the correct order. */
 
 typedef struct {
-  AudioBuffer * buffer_array;   /**< Array that hold pointers of the allocated space for the buffers. */
-  unsigned int tail;            /**< Index of the last element (first to deliver). */
-  unsigned int count;           /**< Number of elements in the array. */
-  unsigned int capacity;        /**< Total length of the array. */
+  AudioBuffer * buffer_array; /**< Array that hold pointers of the allocated
+                                 space for the buffers. */
+  unsigned int tail;     /**< Index of the last element (first to deliver). */
+  unsigned int count;    /**< Number of elements in the array. */
+  unsigned int capacity; /**< Total length of the array. */
 } ring_array;
 
 static int
-single_audiobuffer_init(AudioBuffer * buffer,
-                        uint32_t bytesPerFrame,
-                        uint32_t channelsPerFrame,
-                        uint32_t frames)
+single_audiobuffer_init(AudioBuffer * buffer, uint32_t bytesPerFrame,
+                        uint32_t channelsPerFrame, uint32_t frames)
 {
   assert(buffer);
   assert(bytesPerFrame > 0 && channelsPerFrame && frames > 0);
@@ -36,7 +35,7 @@ single_audiobuffer_init(AudioBuffer * buffer,
   if (buffer->mData == NULL) {
     return CUBEB_ERROR;
   }
-  PodZero(static_cast<char*>(buffer->mData), size);
+  PodZero(static_cast<char *>(buffer->mData), size);
 
   buffer->mNumberChannels = channelsPerFrame;
   buffer->mDataByteSize = size;
@@ -48,15 +47,12 @@ single_audiobuffer_init(AudioBuffer * buffer,
     @param ra The ring_array pointer of allocated structure.
     @retval 0 on success. */
 int
-ring_array_init(ring_array * ra,
-                uint32_t capacity,
-                uint32_t bytesPerFrame,
-                uint32_t channelsPerFrame,
-                uint32_t framesPerBuffer)
+ring_array_init(ring_array * ra, uint32_t capacity, uint32_t bytesPerFrame,
+                uint32_t channelsPerFrame, uint32_t framesPerBuffer)
 {
   assert(ra);
-  if (capacity == 0 || bytesPerFrame == 0 ||
-      channelsPerFrame == 0 || framesPerBuffer == 0) {
+  if (capacity == 0 || bytesPerFrame == 0 || channelsPerFrame == 0 ||
+      framesPerBuffer == 0) {
     return CUBEB_ERROR_INVALID_PARAMETER;
   }
   ra->capacity = capacity;
@@ -70,8 +66,7 @@ ring_array_init(ring_array * ra,
   }
 
   for (unsigned int i = 0; i < ra->capacity; ++i) {
-    if (single_audiobuffer_init(&ra->buffer_array[i],
-                                bytesPerFrame,
+    if (single_audiobuffer_init(&ra->buffer_array[i], bytesPerFrame,
                                 channelsPerFrame,
                                 framesPerBuffer) != CUBEB_OK) {
       return CUBEB_ERROR;
@@ -87,7 +82,7 @@ void
 ring_array_destroy(ring_array * ra)
 {
   assert(ra);
-  if (ra->buffer_array == NULL){
+  if (ra->buffer_array == NULL) {
     return;
   }
   for (unsigned int i = 0; i < ra->capacity; ++i) {
@@ -95,12 +90,13 @@ ring_array_destroy(ring_array * ra)
       operator delete(ra->buffer_array[i].mData);
     }
   }
-  delete [] ra->buffer_array;
+  delete[] ra->buffer_array;
 }
 
 /** Get the allocated buffer to be stored with fresh data.
     @param ra The ring_array pointer.
-    @retval Pointer of the allocated space to be stored with fresh data or NULL if full. */
+    @retval Pointer of the allocated space to be stored with fresh data or NULL
+   if full. */
 AudioBuffer *
 ring_array_get_free_buffer(ring_array * ra)
 {
@@ -156,4 +152,4 @@ ring_array_get_dummy_buffer(ring_array * ra)
   return &ra->buffer_array[0];
 }
 
-#endif //CUBEB_RING_ARRAY_H
+#endif // CUBEB_RING_ARRAY_H
diff --git a/src/cubeb_ringbuffer.h b/src/cubeb_ringbuffer.h
index a5416c3..2838184 100644
--- a/src/cubeb_ringbuffer.h
+++ b/src/cubeb_ringbuffer.h
@@ -18,10 +18,10 @@
 /**
  * Single producer single consumer lock-free and wait-free ring buffer.
  *
- * This data structure allows producing data from one thread, and consuming it on
- * another thread, safely and without explicit synchronization. If used on two
- * threads, this data structure uses atomics for thread safety. It is possible
- * to disable the use of atomics at compile time and only use this data
+ * This data structure allows producing data from one thread, and consuming it
+ * on another thread, safely and without explicit synchronization. If used on
+ * two threads, this data structure uses atomics for thread safety. It is
+ * possible to disable the use of atomics at compile time and only use this data
  * structure on one thread.
  *
  * The role for the producer and the consumer must be constant, i.e., the
@@ -48,9 +48,7 @@
  *   providing an external buffer to copy into is an easy way to have linear
  *   data for further processing.
  */
-template <typename T>
-class ring_buffer_base
-{
+template <typename T> class ring_buffer_base {
 public:
   /**
    * Constructor for a ring buffer.
@@ -61,11 +59,10 @@ public:
    * @param capacity The maximum number of element this ring buffer will hold.
    */
   ring_buffer_base(int capacity)
-    /* One more element to distinguish from empty and full buffer. */
-    : capacity_(capacity + 1)
+      /* One more element to distinguish from empty and full buffer. */
+      : capacity_(capacity + 1)
   {
-    assert(storage_capacity() <
-           std::numeric_limits<int>::max() / 2 &&
+    assert(storage_capacity() < std::numeric_limits<int>::max() / 2 &&
            "buffer too large for the type of index used.");
     assert(capacity_ > 0);
 
@@ -84,10 +81,7 @@ public:
    * @param count The number of elements to enqueue.
    * @return The number of element enqueued.
    */
-  int enqueue_default(int count)
-  {
-    return enqueue(nullptr, count);
-  }
+  int enqueue_default(int count) { return enqueue(nullptr, count); }
   /**
    * @brief Put an element in the queue
    *
@@ -97,20 +91,18 @@ public:
    *
    * @return 1 if the element was inserted, 0 otherwise.
    */
-  int enqueue(T& element)
-  {
-    return enqueue(&element, 1);
-  }
+  int enqueue(T & element) { return enqueue(&element, 1); }
   /**
    * Push `count` elements in the ring buffer.
    *
    * Only safely called on the producer thread.
    *
    * @param elements a pointer to a buffer containing at least `count` elements.
-   * If `elements` is nullptr, zero or default constructed elements are enqueued.
+   * If `elements` is nullptr, zero or default constructed elements are
+   * enqueued.
    * @param count The number of elements to read from `elements`
-   * @return The number of elements successfully coped from `elements` and inserted
-   * into the ring buffer.
+   * @return The number of elements successfully coped from `elements` and
+   * inserted into the ring buffer.
    */
   int enqueue(T * elements, int count)
   {
@@ -125,12 +117,10 @@ public:
       return 0;
     }
 
-    int to_write =
-      std::min(available_write_internal(rd_idx, wr_idx), count);
+    int to_write = std::min(available_write_internal(rd_idx, wr_idx), count);
 
     /* First part, from the write index to the end of the array. */
-    int first_part = std::min(storage_capacity() - wr_idx,
-                                          to_write);
+    int first_part = std::min(storage_capacity() - wr_idx, to_write);
     /* Second part, from the beginning of the array */
     int second_part = to_write - first_part;
 
@@ -142,7 +132,8 @@ public:
       ConstructDefault(data_.get(), second_part);
     }
 
-    write_index_.store(increment_index(wr_idx, to_write), std::memory_order_release);
+    write_index_.store(increment_index(wr_idx, to_write),
+                       std::memory_order_release);
 
     return to_write;
   }
@@ -170,8 +161,7 @@ public:
       return 0;
     }
 
-    int to_read =
-      std::min(available_read_internal(rd_idx, wr_idx), count);
+    int to_read = std::min(available_read_internal(rd_idx, wr_idx), count);
 
     int first_part = std::min(storage_capacity() - rd_idx, to_read);
     int second_part = to_read - first_part;
@@ -181,7 +171,8 @@ public:
       Copy(elements + first_part, data_.get(), second_part);
     }
 
-    read_index_.store(increment_index(rd_idx, to_read), std::memory_order_relaxed);
+    read_index_.store(increment_index(rd_idx, to_read),
+                      std::memory_order_relaxed);
 
     return to_read;
   }
@@ -197,8 +188,9 @@ public:
 #ifndef NDEBUG
     assert_correct_thread(consumer_id);
 #endif
-    return available_read_internal(read_index_.load(std::memory_order_relaxed),
-                                   write_index_.load(std::memory_order_relaxed));
+    return available_read_internal(
+        read_index_.load(std::memory_order_relaxed),
+        write_index_.load(std::memory_order_relaxed));
   }
   /**
    * Get the number of available elements for consuming.
@@ -212,8 +204,9 @@ public:
 #ifndef NDEBUG
     assert_correct_thread(producer_id);
 #endif
-    return available_write_internal(read_index_.load(std::memory_order_relaxed),
-                                    write_index_.load(std::memory_order_relaxed));
+    return available_write_internal(
+        read_index_.load(std::memory_order_relaxed),
+        write_index_.load(std::memory_order_relaxed));
   }
   /**
    * Get the total capacity, for this ring buffer.
@@ -222,10 +215,7 @@ public:
    *
    * @return The maximum capacity of this ring buffer.
    */
-  int capacity() const
-  {
-    return storage_capacity() - 1;
-  }
+  int capacity() const { return storage_capacity() - 1; }
   /**
    * Reset the consumer and producer thread identifier, in case the thread are
    * being changed. This has to be externally synchronized. This is no-op when
@@ -237,6 +227,7 @@ public:
     consumer_id = producer_id = std::thread::id();
 #endif
   }
+
 private:
   /** Return true if the ring buffer is empty.
    *
@@ -244,8 +235,7 @@ private:
    * @param write_index the write index to consider
    * @return true if the ring buffer is empty, false otherwise.
    **/
-  bool empty_internal(int read_index,
-                      int write_index) const
+  bool empty_internal(int read_index, int write_index) const
   {
     return write_index == read_index;
   }
@@ -258,8 +248,7 @@ private:
    * @param write_index the write index to consider
    * @return true if the ring buffer is full, false otherwise.
    **/
-  bool full_internal(int read_index,
-                     int write_index) const
+  bool full_internal(int read_index, int write_index) const
   {
     return (write_index + 1) % storage_capacity() == read_index;
   }
@@ -269,18 +258,13 @@ private:
    *
    * @return the number of elements that can be stored in the buffer.
    */
-  int storage_capacity() const
-  {
-    return capacity_;
-  }
+  int storage_capacity() const { return capacity_; }
   /**
    * Returns the number of elements available for reading.
    *
    * @return the number of available elements for reading.
    */
-  int
-  available_read_internal(int read_index,
-                          int write_index) const
+  int available_read_internal(int read_index, int write_index) const
   {
     if (write_index >= read_index) {
       return write_index - read_index;
@@ -293,9 +277,7 @@ private:
    *
    * @return the number of elements that can be written into the array.
    */
-  int
-  available_write_internal(int read_index,
-                           int write_index) const
+  int available_write_internal(int read_index, int write_index) const
   {
     /* We substract one element here to always keep at least one sample
      * free in the buffer, to distinguish between full and empty array. */
@@ -312,8 +294,7 @@ private:
    * @param increment the number by which `index` is incremented.
    * @return the new index.
    */
-  int
-  increment_index(int index, int increment) const
+  int increment_index(int index, int increment) const
   {
     assert(increment >= 0);
     return (index + increment) % storage_capacity();
@@ -325,7 +306,7 @@ private:
    * @param id the id of the thread that has called the calling method first.
    */
 #ifndef NDEBUG
-  static void assert_correct_thread(std::thread::id& id)
+  static void assert_correct_thread(std::thread::id & id)
   {
     if (id == std::thread::id()) {
       id = std::this_thread::get_id();
@@ -354,9 +335,7 @@ private:
 /**
  * Adapter for `ring_buffer_base` that exposes an interface in frames.
  */
-template <typename T>
-class audio_ring_buffer_base
-{
+template <typename T> class audio_ring_buffer_base {
 public:
   /**
    * @brief Constructor.
@@ -365,8 +344,8 @@ public:
    * @param capacity_in_frames  The capacity in frames.
    */
   audio_ring_buffer_base(int channel_count, int capacity_in_frames)
-    : channel_count(channel_count)
-    , ring_buffer(frames_to_samples(capacity_in_frames))
+      : channel_count(channel_count),
+        ring_buffer(frames_to_samples(capacity_in_frames))
   {
     assert(channel_count > 0);
   }
@@ -380,7 +359,8 @@ public:
    */
   int enqueue_default(int frame_count)
   {
-    return samples_to_frames(ring_buffer.enqueue(nullptr, frames_to_samples(frame_count)));
+    return samples_to_frames(
+        ring_buffer.enqueue(nullptr, frames_to_samples(frame_count)));
   }
   /**
    * @brief Enqueue `frames_count` frames of audio.
@@ -396,7 +376,8 @@ public:
 
   int enqueue(T * frames, int frame_count)
   {
-    return samples_to_frames(ring_buffer.enqueue(frames, frames_to_samples(frame_count)));
+    return samples_to_frames(
+        ring_buffer.enqueue(frames, frames_to_samples(frame_count)));
   }
 
   /**
@@ -413,7 +394,8 @@ public:
    */
   int dequeue(T * frames, int frame_count)
   {
-    return samples_to_frames(ring_buffer.dequeue(frames, frames_to_samples(frame_count)));
+    return samples_to_frames(
+        ring_buffer.dequeue(frames, frames_to_samples(frame_count)));
   }
   /**
    * Get the number of available frames of audio for consuming.
@@ -444,10 +426,8 @@ public:
    *
    * @return The maximum capacity of this ring buffer.
    */
-  int capacity() const
-  {
-    return samples_to_frames(ring_buffer.capacity());
-  }
+  int capacity() const { return samples_to_frames(ring_buffer.capacity()); }
+
 private:
   /**
    * @brief Frames to samples conversion.
@@ -456,10 +436,7 @@ private:
    *
    * @return  A number of samples.
    */
-  int frames_to_samples(int frames) const
-  {
-    return frames * channel_count;
-  }
+  int frames_to_samples(int frames) const { return frames * channel_count; }
   /**
    * @brief Samples to frames conversion.
    *
@@ -467,10 +444,7 @@ private:
    *
    * @return  A number of frames.
    */
-  int samples_to_frames(int samples) const
-  {
-    return samples / channel_count;
-  }
+  int samples_to_frames(int samples) const { return samples / channel_count; }
   /** Number of channels of audio that will stream through this ring buffer. */
   int channel_count;
   /** The underlying ring buffer that is used to store the data. */
@@ -482,14 +456,13 @@ private:
  * from two threads, one producer, one consumer (that never change role),
  * without explicit synchronization.
  */
-template<typename T>
-using lock_free_queue = ring_buffer_base<T>;
+template <typename T> using lock_free_queue = ring_buffer_base<T>;
 /**
  * Lock-free instantiation of the `audio_ring_buffer` type. This is safe to use
  * from two threads, one producer, one consumer (that never change role),
  * without explicit synchronization.
  */
-template<typename T>
+template <typename T>
 using lock_free_audio_ring_buffer = audio_ring_buffer_base<T>;
 
 #endif // CUBEB_RING_BUFFER_H
diff --git a/src/cubeb_sndio.c b/src/cubeb_sndio.c
index 93af1d2..d7fb792 100644
--- a/src/cubeb_sndio.c
+++ b/src/cubeb_sndio.c
@@ -4,44 +4,46 @@
  * This program is made available under an ISC-style license.  See the
  * accompanying file LICENSE for details.
  */
+#include "cubeb-internal.h"
+#include "cubeb/cubeb.h"
+#include <assert.h>
+#include <dlfcn.h>
 #include <inttypes.h>
 #include <math.h>
 #include <poll.h>
 #include <pthread.h>
 #include <sndio.h>
 #include <stdbool.h>
-#include <stdlib.h>
 #include <stdio.h>
-#include <dlfcn.h>
-#include <assert.h>
-#include "cubeb/cubeb.h"
-#include "cubeb-internal.h"
+#include <stdlib.h>
 
 #if defined(CUBEB_SNDIO_DEBUG)
 #define DPR(...) fprintf(stderr, __VA_ARGS__);
 #else
-#define DPR(...) do {} while(0)
+#define DPR(...)                                                               \
+  do {                                                                         \
+  } while (0)
 #endif
 
 #ifdef DISABLE_LIBSNDIO_DLOPEN
 #define WRAP(x) x
 #else
 #define WRAP(x) cubeb_##x
-#define LIBSNDIO_API_VISIT(X)                   \
-  X(sio_close)                               \
-  X(sio_eof)                                 \
-  X(sio_getpar)                              \
-  X(sio_initpar)                             \
-  X(sio_nfds)                                \
-  X(sio_onmove)                              \
-  X(sio_open)                                \
-  X(sio_pollfd)                              \
-  X(sio_read)                                \
-  X(sio_revents)                             \
-  X(sio_setpar)                              \
-  X(sio_start)                               \
-  X(sio_stop)                                \
-  X(sio_write)                               \
+#define LIBSNDIO_API_VISIT(X)                                                  \
+  X(sio_close)                                                                 \
+  X(sio_eof)                                                                   \
+  X(sio_getpar)                                                                \
+  X(sio_initpar)                                                               \
+  X(sio_nfds)                                                                  \
+  X(sio_onmove)                                                                \
+  X(sio_open)                                                                  \
+  X(sio_pollfd)                                                                \
+  X(sio_read)                                                                  \
+  X(sio_revents)                                                               \
+  X(sio_setpar)                                                                \
+  X(sio_start)                                                                 \
+  X(sio_stop)                                                                  \
+  X(sio_write)
 
 #define MAKE_TYPEDEF(x) static typeof(x) * cubeb_##x;
 LIBSNDIO_API_VISIT(MAKE_TYPEDEF);
@@ -58,33 +60,33 @@ struct cubeb {
 struct cubeb_stream {
   /* Note: Must match cubeb_stream layout in cubeb.c. */
   cubeb * context;
-  void * arg;                     /* user arg to {data,state}_cb */
+  void * arg; /* user arg to {data,state}_cb */
   /**/
-  pthread_t th;                   /* to run real-time audio i/o */
-  pthread_mutex_t mtx;            /* protects hdl and pos */
-  struct sio_hdl *hdl;            /* link us to sndio */
-  int mode;			  /* bitmap of SIO_{PLAY,REC} */
-  int active;                     /* cubec_start() called */
-  int conv;                       /* need float->s16 conversion */
-  unsigned char *rbuf;            /* rec data consumed from here */
-  unsigned char *pbuf;            /* play data is prepared here */
-  unsigned int nfr;               /* number of frames in ibuf and obuf */
-  unsigned int rbpf;              /* rec bytes per frame */
-  unsigned int pbpf;              /* play bytes per frame */
-  unsigned int rchan;             /* number of rec channels */
-  unsigned int pchan;             /* number of play channels */
-  unsigned int nblks;		  /* number of blocks in the buffer */
-  uint64_t hwpos;                 /* frame number Joe hears right now */
-  uint64_t swpos;                 /* number of frames produced/consumed */
-  cubeb_data_callback data_cb;    /* cb to preapare data */
-  cubeb_state_callback state_cb;  /* cb to notify about state changes */
-  float volume;			  /* current volume */
+  pthread_t th;                  /* to run real-time audio i/o */
+  pthread_mutex_t mtx;           /* protects hdl and pos */
+  struct sio_hdl * hdl;          /* link us to sndio */
+  int mode;                      /* bitmap of SIO_{PLAY,REC} */
+  int active;                    /* cubec_start() called */
+  int conv;                      /* need float->s16 conversion */
+  unsigned char * rbuf;          /* rec data consumed from here */
+  unsigned char * pbuf;          /* play data is prepared here */
+  unsigned int nfr;              /* number of frames in ibuf and obuf */
+  unsigned int rbpf;             /* rec bytes per frame */
+  unsigned int pbpf;             /* play bytes per frame */
+  unsigned int rchan;            /* number of rec channels */
+  unsigned int pchan;            /* number of play channels */
+  unsigned int nblks;            /* number of blocks in the buffer */
+  uint64_t hwpos;                /* frame number Joe hears right now */
+  uint64_t swpos;                /* number of frames produced/consumed */
+  cubeb_data_callback data_cb;   /* cb to preapare data */
+  cubeb_state_callback state_cb; /* cb to notify about state changes */
+  float volume;                  /* current volume */
 };
 
 static void
-s16_setvol(void *ptr, long nsamp, float volume)
+s16_setvol(void * ptr, long nsamp, float volume)
 {
-  int16_t *dst = ptr;
+  int16_t * dst = ptr;
   int32_t mult = volume * 32768;
   int32_t s;
 
@@ -96,10 +98,10 @@ s16_setvol(void *ptr, long nsamp, float volume)
 }
 
 static void
-float_to_s16(void *ptr, long nsamp, float volume)
+float_to_s16(void * ptr, long nsamp, float volume)
 {
-  int16_t *dst = ptr;
-  float *src = ptr;
+  int16_t * dst = ptr;
+  float * src = ptr;
   float mult = volume * 32768;
   int s;
 
@@ -114,10 +116,10 @@ float_to_s16(void *ptr, long nsamp, float volume)
 }
 
 static void
-s16_to_float(void *ptr, long nsamp)
+s16_to_float(void * ptr, long nsamp)
 {
-  int16_t *src = ptr;
-  float *dst = ptr;
+  int16_t * src = ptr;
+  float * dst = ptr;
 
   src += nsamp;
   dst += nsamp;
@@ -133,9 +135,9 @@ sndio_get_device()
    * On other platforms default to sndio devices,
    * so cubebs other backends can be used instead.
    */
-  const char *dev = getenv("AUDIODEVICE");
+  const char * dev = getenv("AUDIODEVICE");
   if (dev == NULL || *dev == '\0')
-	return "snd/0";
+    return "snd/0";
   return dev;
 #else
   return SIO_DEVANY;
@@ -143,26 +145,26 @@ sndio_get_device()
 }
 
 static void
-sndio_onmove(void *arg, int delta)
+sndio_onmove(void * arg, int delta)
 {
-  cubeb_stream *s = (cubeb_stream *)arg;
+  cubeb_stream * s = (cubeb_stream *)arg;
 
   s->hwpos += delta;
 }
 
 static void *
-sndio_mainloop(void *arg)
+sndio_mainloop(void * arg)
 {
-  struct pollfd *pfds;
-  cubeb_stream *s = arg;
+  struct pollfd * pfds;
+  cubeb_stream * s = arg;
   int n, eof = 0, prime, nfds, events, revents, state = CUBEB_STATE_STARTED;
   size_t pstart = 0, pend = 0, rstart = 0, rend = 0;
   long nfr;
 
   nfds = WRAP(sio_nfds)(s->hdl);
-  pfds = calloc(nfds, sizeof (struct pollfd));
+  pfds = calloc(nfds, sizeof(struct pollfd));
   if (pfds == NULL)
-	  return NULL;
+    return NULL;
 
   DPR("sndio_mainloop()\n");
   s->state_cb(s, s->arg, CUBEB_STATE_STARTED);
@@ -196,7 +198,7 @@ sndio_mainloop(void *arg)
 
     /* do we have a complete block? */
     if ((!(s->mode & SIO_PLAY) || pstart == pend) &&
-	(!(s->mode & SIO_REC) || rstart == rend)) {
+        (!(s->mode & SIO_REC) || rstart == rend)) {
 
       if (eof) {
         DPR("sndio_mainloop() drained\n");
@@ -224,7 +226,7 @@ sndio_mainloop(void *arg)
         if (!(s->mode & SIO_PLAY) || nfr == 0) {
           state = CUBEB_STATE_DRAINED;
           break;
-	}
+        }
 
         /* need to write (aka drain) the partial play block we got */
         pend = nfr * s->pbpf;
@@ -302,10 +304,10 @@ sndio_mainloop(void *arg)
 }
 
 /*static*/ int
-sndio_init(cubeb **context, char const *context_name)
+sndio_init(cubeb ** context, char const * context_name)
 {
   void * libsndio = NULL;
-  struct sio_hdl *hdl;
+  struct sio_hdl * hdl;
 
   assert(context);
 
@@ -319,13 +321,14 @@ sndio_init(cubeb **context, char const *context_name)
     }
   }
 
-#define LOAD(x) {                               \
-    cubeb_##x = dlsym(libsndio, #x);            \
-    if (!cubeb_##x) {                           \
-      DPR("sndio_init(%s) failed dlsym(%s)\n", context_name, #x); \
-      dlclose(libsndio);                        \
-      return CUBEB_ERROR;                       \
-    }                                           \
+#define LOAD(x)                                                                \
+  {                                                                            \
+    cubeb_##x = dlsym(libsndio, #x);                                           \
+    if (!cubeb_##x) {                                                          \
+      DPR("sndio_init(%s) failed dlsym(%s)\n", context_name, #x);              \
+      dlclose(libsndio);                                                       \
+      return CUBEB_ERROR;                                                      \
+    }                                                                          \
   }
 
   LIBSNDIO_API_VISIT(LOAD);
@@ -342,7 +345,7 @@ sndio_init(cubeb **context, char const *context_name)
   DPR("sndio_init(%s)\n", context_name);
   *context = malloc(sizeof(**context));
   if (*context == NULL)
-	return CUBEB_ERROR;
+    return CUBEB_ERROR;
   (*context)->libsndio = libsndio;
   (*context)->ops = &sndio_ops;
   (void)context_name;
@@ -350,13 +353,13 @@ sndio_init(cubeb **context, char const *context_name)
 }
 
 static char const *
-sndio_get_backend_id(cubeb *context)
+sndio_get_backend_id(cubeb * context)
 {
   return "sndio";
 }
 
 static void
-sndio_destroy(cubeb *context)
+sndio_destroy(cubeb * context)
 {
   DPR("sndio_destroy()\n");
   if (context->libsndio)
@@ -365,19 +368,16 @@ sndio_destroy(cubeb *context)
 }
 
 static int
-sndio_stream_init(cubeb * context,
-                  cubeb_stream ** stream,
-                  char const * stream_name,
-                  cubeb_devid input_device,
+sndio_stream_init(cubeb * context, cubeb_stream ** stream,
+                  char const * stream_name, cubeb_devid input_device,
                   cubeb_stream_params * input_stream_params,
                   cubeb_devid output_device,
                   cubeb_stream_params * output_stream_params,
                   unsigned int latency_frames,
                   cubeb_data_callback data_callback,
-                  cubeb_state_callback state_callback,
-                  void *user_ptr)
+                  cubeb_state_callback state_callback, void * user_ptr)
 {
-  cubeb_stream *s;
+  cubeb_stream * s;
   struct sio_par wpar, rpar;
   cubeb_sample_format format;
   int rate;
@@ -445,8 +445,8 @@ sndio_stream_init(cubeb * context,
     DPR("sndio_stream_init(), sio_setpar() failed\n");
     goto err;
   }
-  if (rpar.bits != wpar.bits || rpar.le != wpar.le ||
-      rpar.sig != wpar.sig || rpar.rate != wpar.rate ||
+  if (rpar.bits != wpar.bits || rpar.le != wpar.le || rpar.sig != wpar.sig ||
+      rpar.rate != wpar.rate ||
       ((s->mode & SIO_REC) && rpar.rchan != wpar.rchan) ||
       ((s->mode & SIO_PLAY) && rpar.pchan != wpar.pchan)) {
     DPR("sndio_stream_init() unsupported params\n");
@@ -522,7 +522,8 @@ sndio_get_preferred_sample_rate(cubeb * ctx, uint32_t * rate)
 }
 
 static int
-sndio_get_min_latency(cubeb * ctx, cubeb_stream_params params, uint32_t * latency_frames)
+sndio_get_min_latency(cubeb * ctx, cubeb_stream_params params,
+                      uint32_t * latency_frames)
 {
   /*
    * We've no device-independent minimum latency.
@@ -533,7 +534,7 @@ sndio_get_min_latency(cubeb * ctx, cubeb_stream_params params, uint32_t * latenc
 }
 
 static void
-sndio_stream_destroy(cubeb_stream *s)
+sndio_stream_destroy(cubeb_stream * s)
 {
   DPR("sndio_stream_destroy()\n");
   WRAP(sio_close)(s->hdl);
@@ -545,7 +546,7 @@ sndio_stream_destroy(cubeb_stream *s)
 }
 
 static int
-sndio_stream_start(cubeb_stream *s)
+sndio_stream_start(cubeb_stream * s)
 {
   int err;
 
@@ -560,9 +561,9 @@ sndio_stream_start(cubeb_stream *s)
 }
 
 static int
-sndio_stream_stop(cubeb_stream *s)
+sndio_stream_stop(cubeb_stream * s)
 {
-  void *dummy;
+  void * dummy;
 
   DPR("sndio_stream_stop()\n");
   if (s->active) {
@@ -573,7 +574,7 @@ sndio_stream_stop(cubeb_stream *s)
 }
 
 static int
-sndio_stream_get_position(cubeb_stream *s, uint64_t *p)
+sndio_stream_get_position(cubeb_stream * s, uint64_t * p)
 {
   pthread_mutex_lock(&s->mtx);
   DPR("sndio_stream_get_position() %" PRId64 "\n", s->hwpos);
@@ -583,7 +584,7 @@ sndio_stream_get_position(cubeb_stream *s, uint64_t *p)
 }
 
 static int
-sndio_stream_set_volume(cubeb_stream *s, float volume)
+sndio_stream_set_volume(cubeb_stream * s, float volume)
 {
   DPR("sndio_stream_set_volume(%f)\n", volume);
   pthread_mutex_lock(&s->mtx);
@@ -606,22 +607,22 @@ sndio_stream_get_latency(cubeb_stream * stm, uint32_t * latency)
 }
 
 static int
-sndio_enumerate_devices(cubeb *context, cubeb_device_type type,
-	cubeb_device_collection *collection)
+sndio_enumerate_devices(cubeb * context, cubeb_device_type type,
+                        cubeb_device_collection * collection)
 {
   static char dev[] = SIO_DEVANY;
-  cubeb_device_info *device;
+  cubeb_device_info * device;
 
   device = malloc(sizeof(cubeb_device_info));
   if (device == NULL)
     return CUBEB_ERROR;
 
-  device->devid = dev;		/* passed to stream_init() */
-  device->device_id = dev;	/* printable in UI */
-  device->friendly_name = dev;	/* same, but friendly */
-  device->group_id = dev;	/* actual device if full-duplex */
-  device->vendor_name = NULL;   /* may be NULL */
-  device->type = type;		/* Input/Output */
+  device->devid = dev;         /* passed to stream_init() */
+  device->device_id = dev;     /* printable in UI */
+  device->friendly_name = dev; /* same, but friendly */
+  device->group_id = dev;      /* actual device if full-duplex */
+  device->vendor_name = NULL;  /* may be NULL */
+  device->type = type;         /* Input/Output */
   device->state = CUBEB_DEVICE_STATE_ENABLED;
   device->preferred = CUBEB_DEVICE_PREF_ALL;
   device->format = CUBEB_DEVICE_FMT_S16NE;
@@ -639,31 +640,30 @@ sndio_enumerate_devices(cubeb *context, cubeb_device_type type,
 
 static int
 sndio_device_collection_destroy(cubeb * context,
-	cubeb_device_collection * collection)
+                                cubeb_device_collection * collection)
 {
   free(collection->device);
   return CUBEB_OK;
 }
 
 static struct cubeb_ops const sndio_ops = {
-  .init = sndio_init,
-  .get_backend_id = sndio_get_backend_id,
-  .get_max_channel_count = sndio_get_max_channel_count,
-  .get_min_latency = sndio_get_min_latency,
-  .get_preferred_sample_rate = sndio_get_preferred_sample_rate,
-  .enumerate_devices = sndio_enumerate_devices,
-  .device_collection_destroy = sndio_device_collection_destroy,
-  .destroy = sndio_destroy,
-  .stream_init = sndio_stream_init,
-  .stream_destroy = sndio_stream_destroy,
-  .stream_start = sndio_stream_start,
-  .stream_stop = sndio_stream_stop,
-  .stream_get_position = sndio_stream_get_position,
-  .stream_get_latency = sndio_stream_get_latency,
-  .stream_set_volume = sndio_stream_set_volume,
-  .stream_set_name = NULL,
-  .stream_get_current_device = NULL,
-  .stream_device_destroy = NULL,
-  .stream_register_device_changed_callback = NULL,
-  .register_device_collection_changed = NULL
-};
+    .init = sndio_init,
+    .get_backend_id = sndio_get_backend_id,
+    .get_max_channel_count = sndio_get_max_channel_count,
+    .get_min_latency = sndio_get_min_latency,
+    .get_preferred_sample_rate = sndio_get_preferred_sample_rate,
+    .enumerate_devices = sndio_enumerate_devices,
+    .device_collection_destroy = sndio_device_collection_destroy,
+    .destroy = sndio_destroy,
+    .stream_init = sndio_stream_init,
+    .stream_destroy = sndio_stream_destroy,
+    .stream_start = sndio_stream_start,
+    .stream_stop = sndio_stream_stop,
+    .stream_get_position = sndio_stream_get_position,
+    .stream_get_latency = sndio_stream_get_latency,
+    .stream_set_volume = sndio_stream_set_volume,
+    .stream_set_name = NULL,
+    .stream_get_current_device = NULL,
+    .stream_device_destroy = NULL,
+    .stream_register_device_changed_callback = NULL,
+    .register_device_collection_changed = NULL};
diff --git a/src/cubeb_strings.c b/src/cubeb_strings.c
index 79d7d21..5fe5b79 100644
--- a/src/cubeb_strings.c
+++ b/src/cubeb_strings.c
@@ -23,7 +23,7 @@ struct cubeb_strings {
 int
 cubeb_strings_init(cubeb_strings ** strings)
 {
-  cubeb_strings* strs = NULL;
+  cubeb_strings * strs = NULL;
 
   if (!strings) {
     return CUBEB_ERROR;
@@ -58,7 +58,7 @@ cubeb_strings_destroy(cubeb_strings * strings)
   sp = strings->data;
   se = sp + strings->count;
 
-  for ( ;  sp != se; sp++) {
+  for (; sp != se; sp++) {
     if (*sp) {
       free(*sp);
     }
@@ -88,7 +88,7 @@ cubeb_strings_lookup(cubeb_strings * strings, char const * s)
   sp = strings->data;
   se = sp + strings->count;
 
-  for ( ; sp != se; sp++) {
+  for (; sp != se; sp++) {
     if (*sp && strcmp(*sp, s) == 0) {
       return *sp;
     }
@@ -152,4 +152,3 @@ cubeb_strings_intern(cubeb_strings * strings, char const * s)
 
   return cubeb_strings_push(strings, s);
 }
-
diff --git a/src/cubeb_strings.h b/src/cubeb_strings.h
index a918a01..cfffbbc 100644
--- a/src/cubeb_strings.h
+++ b/src/cubeb_strings.h
@@ -22,12 +22,14 @@ typedef struct cubeb_strings cubeb_strings;
     interned string storage will be returned.
     @retval CUBEB_OK in case of success.
     @retval CUBEB_ERROR in case of error. */
-CUBEB_EXPORT int cubeb_strings_init(cubeb_strings ** strings);
+CUBEB_EXPORT int
+cubeb_strings_init(cubeb_strings ** strings);
 
 /** Destroy an interned string structure freeing all associated memory.
     @param strings An opaque pointer to the interned string storage to
                    destroy. */
-CUBEB_EXPORT void cubeb_strings_destroy(cubeb_strings * strings);
+CUBEB_EXPORT void
+cubeb_strings_destroy(cubeb_strings * strings);
 
 /** Add string to internal storage.
     @param strings Opaque pointer to interned string storage.
@@ -35,7 +37,8 @@ CUBEB_EXPORT void cubeb_strings_destroy(cubeb_strings * strings);
     @retval CUBEB_OK
     @retval CUBEB_ERROR
  */
-CUBEB_EXPORT char const * cubeb_strings_intern(cubeb_strings * strings, char const * s);
+CUBEB_EXPORT char const *
+cubeb_strings_intern(cubeb_strings * strings, char const * s);
 
 #if defined(__cplusplus)
 }
diff --git a/src/cubeb_sun.c b/src/cubeb_sun.c
index dda0919..3b7bef7 100644
--- a/src/cubeb_sun.c
+++ b/src/cubeb_sun.c
@@ -4,18 +4,18 @@
  * This program is made available under an ISC-style license.  See the
  * accompanying file LICENSE for details.
  */
-#include <sys/audioio.h>
-#include <sys/ioctl.h>
+#include "cubeb-internal.h"
+#include "cubeb/cubeb.h"
 #include <fcntl.h>
-#include <unistd.h>
+#include <limits.h>
 #include <pthread.h>
 #include <stdbool.h>
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
-#include <limits.h>
-#include "cubeb/cubeb.h"
-#include "cubeb-internal.h"
+#include <sys/audioio.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
 
 /* Default to 4 + 1 for the default device. */
 #ifndef SUN_DEVICE_COUNT
@@ -45,11 +45,11 @@
  */
 
 #ifndef SUN_MAX_CHANNELS
-# ifdef __NetBSD__
-#  define SUN_MAX_CHANNELS (12)
-# else
-#  define SUN_MAX_CHANNELS (2)
-# endif
+#ifdef __NetBSD__
+#define SUN_MAX_CHANNELS (12)
+#else
+#define SUN_MAX_CHANNELS (2)
+#endif
 #endif
 
 #ifndef SUN_MIN_RATE
@@ -145,8 +145,8 @@ sun_get_min_latency(cubeb * context, cubeb_stream_params params,
 }
 
 static int
-sun_get_hwinfo(const char * device, struct audio_info * format,
-               int * props, struct audio_device * dev)
+sun_get_hwinfo(const char * device, struct audio_info * format, int * props,
+               struct audio_device * dev)
 {
   int fd = -1;
 
@@ -181,9 +181,10 @@ error:
 static int
 sun_prinfo_verify_sanity(struct audio_prinfo * prinfo)
 {
-   return prinfo->precision >= 8 && prinfo->precision <= 32 &&
-     prinfo->channels >= 1 && prinfo->channels < SUN_MAX_CHANNELS &&
-     prinfo->sample_rate < SUN_MAX_RATE && prinfo->sample_rate > SUN_MIN_RATE;
+  return prinfo->precision >= 8 && prinfo->precision <= 32 &&
+         prinfo->channels >= 1 && prinfo->channels < SUN_MAX_CHANNELS &&
+         prinfo->sample_rate < SUN_MAX_RATE &&
+         prinfo->sample_rate > SUN_MIN_RATE;
 }
 
 static int
@@ -196,7 +197,7 @@ sun_enumerate_devices(cubeb * context, cubeb_device_type type,
   char dev_friendly[64];
   struct audio_info hwfmt;
   struct audio_device hwname;
-  struct audio_prinfo *prinfo = NULL;
+  struct audio_prinfo * prinfo = NULL;
   int hwprops;
 
   collection->device = calloc(SUN_DEVICE_COUNT, sizeof(cubeb_device_info));
@@ -262,7 +263,8 @@ sun_enumerate_devices(cubeb * context, cubeb_device_type type,
     device.vendor_name = strdup(hwname.name);
     device.type = type;
     device.state = CUBEB_DEVICE_STATE_ENABLED;
-    device.preferred = (i == 0) ? CUBEB_DEVICE_PREF_ALL : CUBEB_DEVICE_PREF_NONE;
+    device.preferred =
+        (i == 0) ? CUBEB_DEVICE_PREF_ALL : CUBEB_DEVICE_PREF_NONE;
 #ifdef AUDIO_GETFORMAT
     device.max_channels = prinfo->channels;
     device.default_rate = prinfo->sample_rate;
@@ -393,7 +395,7 @@ sun_float_to_linear32(void * buf, unsigned sample_count, float vol)
 }
 
 static void
-sun_linear32_to_float(void * buf, unsigned sample_count) 
+sun_linear32_to_float(void * buf, unsigned sample_count)
 {
   int32_t * in = buf;
   float * out = buf;
@@ -418,7 +420,7 @@ sun_linear16_set_vol(int16_t * buf, unsigned sample_count, float vol)
 static void *
 sun_io_routine(void * arg)
 {
-  cubeb_stream *s = arg;
+  cubeb_stream * s = arg;
   cubeb_state state = CUBEB_STATE_STARTED;
   size_t to_read = 0;
   long to_write = 0;
@@ -439,8 +441,8 @@ sun_io_routine(void * arg)
       sun_linear32_to_float(s->record.buf,
                             s->record.info.record.channels * SUN_BUFFER_FRAMES);
     }
-    to_write = s->data_cb(s, s->user_ptr,
-                          s->record.buf, s->play.buf, SUN_BUFFER_FRAMES);
+    to_write = s->data_cb(s, s->user_ptr, s->record.buf, s->play.buf,
+                          SUN_BUFFER_FRAMES);
     if (to_write == CUBEB_ERROR) {
       state = CUBEB_STATE_ERROR;
       break;
@@ -456,8 +458,8 @@ sun_io_routine(void * arg)
         sun_float_to_linear32(s->play.buf,
                               s->play.info.play.channels * to_write, vol);
       } else {
-        sun_linear16_set_vol(s->play.buf,
-                             s->play.info.play.channels * to_write, vol);
+        sun_linear16_set_vol(s->play.buf, s->play.info.play.channels * to_write,
+                             vol);
       }
     }
     if (to_write < SUN_BUFFER_FRAMES) {
@@ -473,7 +475,8 @@ sun_io_routine(void * arg)
 
       if (to_write > 0) {
         bytes = to_write * s->play.frame_size;
-        if ((n = write(s->play.fd, (uint8_t *)s->play.buf + write_ofs, bytes)) < 0) {
+        if ((n = write(s->play.fd, (uint8_t *)s->play.buf + write_ofs, bytes)) <
+            0) {
           state = CUBEB_STATE_ERROR;
           break;
         }
@@ -486,7 +489,8 @@ sun_io_routine(void * arg)
       }
       if (to_read > 0) {
         bytes = to_read * s->record.frame_size;
-        if ((n = read(s->record.fd, (uint8_t *)s->record.buf + read_ofs, bytes)) < 0) {
+        if ((n = read(s->record.fd, (uint8_t *)s->record.buf + read_ofs,
+                      bytes)) < 0) {
           state = CUBEB_STATE_ERROR;
           break;
         }
@@ -505,20 +509,16 @@ sun_io_routine(void * arg)
 }
 
 static int
-sun_stream_init(cubeb * context,
-                cubeb_stream ** stream,
-                char const * stream_name,
-                cubeb_devid input_device,
+sun_stream_init(cubeb * context, cubeb_stream ** stream,
+                char const * stream_name, cubeb_devid input_device,
                 cubeb_stream_params * input_stream_params,
                 cubeb_devid output_device,
                 cubeb_stream_params * output_stream_params,
-                unsigned latency_frames,
-                cubeb_data_callback data_callback,
-                cubeb_state_callback state_callback,
-                void * user_ptr)
+                unsigned latency_frames, cubeb_data_callback data_callback,
+                cubeb_state_callback state_callback, void * user_ptr)
 {
   int ret = CUBEB_OK;
-  cubeb_stream *s = NULL;
+  cubeb_stream * s = NULL;
 
   (void)stream_name;
   (void)latency_frames;
@@ -529,14 +529,14 @@ sun_stream_init(cubeb * context,
   s->record.fd = -1;
   s->play.fd = -1;
   if (input_device != 0) {
-    snprintf(s->record.name, sizeof(s->record.name),
-      "/dev/audio%zu", (uintptr_t)input_device - 1);
+    snprintf(s->record.name, sizeof(s->record.name), "/dev/audio%zu",
+             (uintptr_t)input_device - 1);
   } else {
     snprintf(s->record.name, sizeof(s->record.name), "%s", SUN_DEFAULT_DEVICE);
   }
   if (output_device != 0) {
-    snprintf(s->play.name, sizeof(s->play.name),
-      "/dev/audio%zu", (uintptr_t)output_device - 1);
+    snprintf(s->play.name, sizeof(s->play.name), "/dev/audio%zu",
+             (uintptr_t)output_device - 1);
   } else {
     snprintf(s->play.name, sizeof(s->play.name), "%s", SUN_DEFAULT_DEVICE);
   }
@@ -558,11 +558,13 @@ sun_stream_init(cubeb * context,
     s->record.info.mode = AUMODE_RECORD;
 #endif
     if ((ret = sun_copy_params(s->record.fd, s, input_stream_params,
-                               &s->record.info, &s->record.info.record)) != CUBEB_OK) {
+                               &s->record.info, &s->record.info.record)) !=
+        CUBEB_OK) {
       LOG("Setting record params failed");
       goto error;
     }
-    s->record.floating = (input_stream_params->format == CUBEB_SAMPLE_FLOAT32NE);
+    s->record.floating =
+        (input_stream_params->format == CUBEB_SAMPLE_FLOAT32NE);
   }
   if (output_stream_params != NULL) {
     if (output_stream_params->prefs & CUBEB_STREAM_PREF_LOOPBACK) {
@@ -582,7 +584,8 @@ sun_stream_init(cubeb * context,
     s->play.info.mode = AUMODE_PLAY;
 #endif
     if ((ret = sun_copy_params(s->play.fd, s, output_stream_params,
-                               &s->play.info, &s->play.info.play)) != CUBEB_OK) {
+                               &s->play.info, &s->play.info.play)) !=
+        CUBEB_OK) {
       LOG("Setting play params failed");
       goto error;
     }
@@ -597,17 +600,18 @@ sun_stream_init(cubeb * context,
     LOG("Failed to create mutex");
     goto error;
   }
-  s->play.frame_size = s->play.info.play.channels *
-                      (s->play.info.play.precision / 8);
+  s->play.frame_size =
+      s->play.info.play.channels * (s->play.info.play.precision / 8);
   if (s->play.fd != -1 &&
-     (s->play.buf = calloc(SUN_BUFFER_FRAMES, s->play.frame_size)) == NULL) {
+      (s->play.buf = calloc(SUN_BUFFER_FRAMES, s->play.frame_size)) == NULL) {
     ret = CUBEB_ERROR;
     goto error;
   }
-  s->record.frame_size = s->record.info.record.channels *
-                        (s->record.info.record.precision / 8);
+  s->record.frame_size =
+      s->record.info.record.channels * (s->record.info.record.precision / 8);
   if (s->record.fd != -1 &&
-     (s->record.buf = calloc(SUN_BUFFER_FRAMES, s->record.frame_size)) == NULL) {
+      (s->record.buf = calloc(SUN_BUFFER_FRAMES, s->record.frame_size)) ==
+          NULL) {
     ret = CUBEB_ERROR;
     goto error;
   }
@@ -688,10 +692,10 @@ sun_get_current_device(cubeb_stream * stream, cubeb_device ** const device)
   if (*device == NULL) {
     return CUBEB_ERROR;
   }
-  (*device)->input_name = stream->record.fd != -1 ?
-    strdup(stream->record.name) : NULL;
-  (*device)->output_name = stream->play.fd != -1 ?
-    strdup(stream->play.name) : NULL;
+  (*device)->input_name =
+      stream->record.fd != -1 ? strdup(stream->record.name) : NULL;
+  (*device)->output_name =
+      stream->play.fd != -1 ? strdup(stream->play.name) : NULL;
   return CUBEB_OK;
 }
 
@@ -706,25 +710,24 @@ sun_stream_device_destroy(cubeb_stream * stream, cubeb_device * device)
 }
 
 static struct cubeb_ops const sun_ops = {
-  .init = sun_init,
-  .get_backend_id = sun_get_backend_id,
-  .get_max_channel_count = sun_get_max_channel_count,
-  .get_min_latency = sun_get_min_latency,
-  .get_preferred_sample_rate = sun_get_preferred_sample_rate,
-  .enumerate_devices = sun_enumerate_devices,
-  .device_collection_destroy = sun_device_collection_destroy,
-  .destroy = sun_destroy,
-  .stream_init = sun_stream_init,
-  .stream_destroy = sun_stream_destroy,
-  .stream_start = sun_stream_start,
-  .stream_stop = sun_stream_stop,
-  .stream_get_position = sun_stream_get_position,
-  .stream_get_latency = sun_stream_get_latency,
-  .stream_get_input_latency = NULL,
-  .stream_set_volume = sun_stream_set_volume,
-  .stream_set_name = NULL,
-  .stream_get_current_device = sun_get_current_device,
-  .stream_device_destroy = sun_stream_device_destroy,
-  .stream_register_device_changed_callback = NULL,
-  .register_device_collection_changed = NULL
-};
+    .init = sun_init,
+    .get_backend_id = sun_get_backend_id,
+    .get_max_channel_count = sun_get_max_channel_count,
+    .get_min_latency = sun_get_min_latency,
+    .get_preferred_sample_rate = sun_get_preferred_sample_rate,
+    .enumerate_devices = sun_enumerate_devices,
+    .device_collection_destroy = sun_device_collection_destroy,
+    .destroy = sun_destroy,
+    .stream_init = sun_stream_init,
+    .stream_destroy = sun_stream_destroy,
+    .stream_start = sun_stream_start,
+    .stream_stop = sun_stream_stop,
+    .stream_get_position = sun_stream_get_position,
+    .stream_get_latency = sun_stream_get_latency,
+    .stream_get_input_latency = NULL,
+    .stream_set_volume = sun_stream_set_volume,
+    .stream_set_name = NULL,
+    .stream_get_current_device = sun_get_current_device,
+    .stream_device_destroy = sun_stream_device_destroy,
+    .stream_register_device_changed_callback = NULL,
+    .register_device_collection_changed = NULL};
diff --git a/src/cubeb_utils.cpp b/src/cubeb_utils.cpp
index d42e951..dd1aef7 100644
--- a/src/cubeb_utils.cpp
+++ b/src/cubeb_utils.cpp
@@ -7,18 +7,19 @@
 
 #include "cubeb_utils.h"
 
-size_t cubeb_sample_size(cubeb_sample_format format)
+size_t
+cubeb_sample_size(cubeb_sample_format format)
 {
   switch (format) {
-    case CUBEB_SAMPLE_S16LE:
-    case CUBEB_SAMPLE_S16BE:
-      return sizeof(int16_t);
-    case CUBEB_SAMPLE_FLOAT32LE:
-    case CUBEB_SAMPLE_FLOAT32BE:
-      return sizeof(float);
-    default:
-      // should never happen as all cases are handled above.
-      assert(false);
-      return 0;
+  case CUBEB_SAMPLE_S16LE:
+  case CUBEB_SAMPLE_S16BE:
+    return sizeof(int16_t);
+  case CUBEB_SAMPLE_FLOAT32LE:
+  case CUBEB_SAMPLE_FLOAT32BE:
+    return sizeof(float);
+  default:
+    // should never happen as all cases are handled above.
+    assert(false);
+    return 0;
   }
 }
diff --git a/src/cubeb_utils.h b/src/cubeb_utils.h
index df67511..fd7a3d7 100644
--- a/src/cubeb_utils.h
+++ b/src/cubeb_utils.h
@@ -12,10 +12,10 @@
 
 #ifdef __cplusplus
 
-#include <stdint.h>
-#include <string.h>
 #include <assert.h>
 #include <mutex>
+#include <stdint.h>
+#include <string.h>
 #include <type_traits>
 #if defined(_WIN32)
 #include "cubeb_utils_win.h"
@@ -24,8 +24,9 @@
 #endif
 
 /** Similar to memcpy, but accounts for the size of an element. */
-template<typename T>
-void PodCopy(T * destination, const T * source, size_t count)
+template <typename T>
+void
+PodCopy(T * destination, const T * source, size_t count)
 {
   static_assert(std::is_trivial<T>::value, "Requires trivial type");
   assert(destination && source);
@@ -33,8 +34,9 @@ void PodCopy(T * destination, const T * source, size_t count)
 }
 
 /** Similar to memmove, but accounts for the size of an element. */
-template<typename T>
-void PodMove(T * destination, const T * source, size_t count)
+template <typename T>
+void
+PodMove(T * destination, const T * source, size_t count)
 {
   static_assert(std::is_trivial<T>::value, "Requires trivial type");
   assert(destination && source);
@@ -42,133 +44,118 @@ void PodMove(T * destination, const T * source, size_t count)
 }
 
 /** Similar to a memset to zero, but accounts for the size of an element. */
-template<typename T>
-void PodZero(T * destination, size_t count)
+template <typename T>
+void
+PodZero(T * destination, size_t count)
 {
   static_assert(std::is_trivial<T>::value, "Requires trivial type");
   assert(destination);
-  memset(destination, 0,  count * sizeof(T));
+  memset(destination, 0, count * sizeof(T));
 }
 
 namespace {
-template<typename T, typename Trait>
-void Copy(T * destination, const T * source, size_t count, Trait)
+template <typename T, typename Trait>
+void
+Copy(T * destination, const T * source, size_t count, Trait)
 {
   for (size_t i = 0; i < count; i++) {
     destination[i] = source[i];
   }
 }
 
-template<typename T>
-void Copy(T * destination, const T * source, size_t count, std::true_type)
+template <typename T>
+void
+Copy(T * destination, const T * source, size_t count, std::true_type)
 {
   PodCopy(destination, source, count);
 }
-}
+} // namespace
 
 /**
  * This allows copying a number of elements from a `source` pointer to a
  * `destination` pointer, using `memcpy` if it is safe to do so, or a loop that
  * calls the constructors and destructors otherwise.
  */
-template<typename T>
-void Copy(T * destination, const T * source, size_t count)
+template <typename T>
+void
+Copy(T * destination, const T * source, size_t count)
 {
   assert(destination && source);
   Copy(destination, source, count, typename std::is_trivial<T>::type());
 }
 
 namespace {
-template<typename T, typename Trait>
-void ConstructDefault(T * destination, size_t count, Trait)
+template <typename T, typename Trait>
+void
+ConstructDefault(T * destination, size_t count, Trait)
 {
   for (size_t i = 0; i < count; i++) {
     destination[i] = T();
   }
 }
 
-template<typename T>
-void ConstructDefault(T * destination,
-                      size_t count, std::true_type)
+template <typename T>
+void
+ConstructDefault(T * destination, size_t count, std::true_type)
 {
   PodZero(destination, count);
 }
-}
+} // namespace
 
 /**
  * This allows zeroing (using memset) or default-constructing a number of
  * elements calling the constructors and destructors if necessary.
  */
-template<typename T>
-void ConstructDefault(T * destination, size_t count)
+template <typename T>
+void
+ConstructDefault(T * destination, size_t count)
 {
   assert(destination);
-  ConstructDefault(destination, count,
-                   typename std::is_arithmetic<T>::type());
+  ConstructDefault(destination, count, typename std::is_arithmetic<T>::type());
 }
 
-template<typename T>
-class auto_array
-{
+template <typename T> class auto_array {
 public:
   explicit auto_array(uint32_t capacity = 0)
-    : data_(capacity ? new T[capacity] : nullptr)
-    , capacity_(capacity)
-    , length_(0)
-  {}
-
-  ~auto_array()
+      : data_(capacity ? new T[capacity] : nullptr), capacity_(capacity),
+        length_(0)
   {
-    delete [] data_;
   }
 
+  ~auto_array() { delete[] data_; }
+
   /** Get a constant pointer to the underlying data. */
-  T * data() const
-  {
-    return data_;
-  }
+  T * data() const { return data_; }
 
-  T * end() const
-  {
-    return data_ + length_;
-  }
+  T * end() const { return data_ + length_; }
 
-  const T& at(size_t index) const
+  const T & at(size_t index) const
   {
     assert(index < length_ && "out of range");
     return data_[index];
   }
 
-  T& at(size_t index)
+  T & at(size_t index)
   {
     assert(index < length_ && "out of range");
     return data_[index];
   }
 
   /** Get how much underlying storage this auto_array has. */
-  size_t capacity() const
-  {
-    return capacity_;
-  }
+  size_t capacity() const { return capacity_; }
 
   /** Get how much elements this auto_array contains. */
-  size_t length() const
-  {
-    return length_;
-  }
+  size_t length() const { return length_; }
 
   /** Keeps the storage, but removes all the elements from the array. */
-  void clear()
-  {
-    length_ = 0;
-  }
+  void clear() { length_ = 0; }
 
-   /** Change the storage of this auto array, copying the elements to the new
-    * storage.
-    * @returns true in case of success
-    * @returns false if the new capacity is not big enough to accomodate for the
-    *                elements in the array.
-    */
+  /** Change the storage of this auto array, copying the elements to the new
+   * storage.
+   * @returns true in case of success
+   * @returns false if the new capacity is not big enough to accomodate for the
+   *                elements in the array.
+   */
   bool reserve(size_t new_capacity)
   {
     if (new_capacity < length_) {
@@ -179,17 +166,17 @@ public:
       PodCopy(new_data, data_, length_);
     }
     capacity_ = new_capacity;
-    delete [] data_;
+    delete[] data_;
     data_ = new_data;
 
     return true;
   }
 
-   /** Append `length` elements to the end of the array, resizing the array if
-    * needed.
-    * @parameter elements the elements to append to the array.
-    * @parameter length the number of elements to append to the array.
-    */
+  /** Append `length` elements to the end of the array, resizing the array if
+   * needed.
+   * @parameter elements the elements to append to the array.
+   * @parameter length the number of elements to append to the array.
+   */
   void push(const T * elements, size_t length)
   {
     if (length_ + length > capacity_) {
@@ -227,17 +214,14 @@ public:
   }
 
   /** Return the number of free elements in the array. */
-  size_t available() const
-  {
-    return capacity_ - length_;
-  }
+  size_t available() const { return capacity_ - length_; }
 
   /** Copies `length` elements to `elements` if it is not null, and shift
-    * the remaining elements of the `auto_array` to the beginning.
-    * @parameter elements a buffer to copy the elements to, or nullptr.
-    * @parameter length the number of elements to copy.
-    * @returns true in case of success.
-    * @returns false if the auto_array contains less than `length` elements. */
+   * the remaining elements of the `auto_array` to the beginning.
+   * @parameter elements a buffer to copy the elements to, or nullptr.
+   * @parameter length the number of elements to copy.
+   * @returns true in case of success.
+   * @returns false if the auto_array contains less than `length` elements. */
   bool pop(T * elements, size_t length)
   {
     if (length > length_) {
@@ -285,56 +269,38 @@ template <typename T>
 struct auto_array_wrapper_impl : public auto_array_wrapper {
   auto_array_wrapper_impl() {}
 
-  explicit auto_array_wrapper_impl(uint32_t size)
-    : ar(size)
-  {}
+  explicit auto_array_wrapper_impl(uint32_t size) : ar(size) {}
 
-  void push(void * elements, size_t length) override {
+  void push(void * elements, size_t length) override
+  {
     ar.push(static_cast<T *>(elements), length);
   }
 
-  size_t length() override {
-    return ar.length();
-  }
+  size_t length() override { return ar.length(); }
 
-  void push_silence(size_t length) override {
-    ar.push_silence(length);
-  }
+  void push_silence(size_t length) override { ar.push_silence(length); }
 
-  bool pop(size_t length) override {
-    return ar.pop(nullptr, length);
-  }
+  bool pop(size_t length) override { return ar.pop(nullptr, length); }
 
-  void * data() override {
-    return ar.data();
-  }
+  void * data() override { return ar.data(); }
 
-  void * end() override {
-    return ar.end();
-  }
+  void * end() override { return ar.end(); }
 
-  void clear() override {
-    ar.clear();
-  }
+  void clear() override { ar.clear(); }
 
-  bool reserve(size_t capacity) override {
-    return ar.reserve(capacity);
-  }
+  bool reserve(size_t capacity) override { return ar.reserve(capacity); }
 
-  void set_length(size_t length) override {
-    ar.set_length(length);
-  }
+  void set_length(size_t length) override { ar.set_length(length); }
 
-  ~auto_array_wrapper_impl() {
-    ar.clear();
-  }
+  ~auto_array_wrapper_impl() { ar.clear(); }
 
 private:
   auto_array<T> ar;
 };
 
 extern "C" {
-  size_t cubeb_sample_size(cubeb_sample_format format);
+size_t
+cubeb_sample_size(cubeb_sample_format format);
 }
 
 using auto_lock = std::lock_guard<owned_critical_section>;
diff --git a/src/cubeb_utils_unix.h b/src/cubeb_utils_unix.h
index 4876d01..b6618ca 100644
--- a/src/cubeb_utils_unix.h
+++ b/src/cubeb_utils_unix.h
@@ -8,13 +8,12 @@
 #if !defined(CUBEB_UTILS_UNIX)
 #define CUBEB_UTILS_UNIX
 
-#include <pthread.h>
 #include <errno.h>
+#include <pthread.h>
 #include <stdio.h>
 
 /* This wraps a critical section to track the owner in debug mode. */
-class owned_critical_section
-{
+class owned_critical_section {
 public:
   owned_critical_section()
   {
@@ -29,7 +28,7 @@ public:
 #ifndef NDEBUG
     int r =
 #endif
-    pthread_mutex_init(&mutex, &attr);
+        pthread_mutex_init(&mutex, &attr);
 #ifndef NDEBUG
     assert(r == 0);
 #endif
@@ -42,7 +41,7 @@ public:
 #ifndef NDEBUG
     int r =
 #endif
-    pthread_mutex_destroy(&mutex);
+        pthread_mutex_destroy(&mutex);
 #ifndef NDEBUG
     assert(r == 0);
 #endif
@@ -53,7 +52,7 @@ public:
 #ifndef NDEBUG
     int r =
 #endif
-    pthread_mutex_lock(&mutex);
+        pthread_mutex_lock(&mutex);
 #ifndef NDEBUG
     assert(r == 0 && "Deadlock");
 #endif
@@ -64,7 +63,7 @@ public:
 #ifndef NDEBUG
     int r =
 #endif
-    pthread_mutex_unlock(&mutex);
+        pthread_mutex_unlock(&mutex);
 #ifndef NDEBUG
     assert(r == 0 && "Unlocking unlocked mutex");
 #endif
@@ -82,8 +81,8 @@ private:
   pthread_mutex_t mutex;
 
   // Disallow copy and assignment because pthread_mutex_t cannot be copied.
-  owned_critical_section(const owned_critical_section&);
-  owned_critical_section& operator=(const owned_critical_section&);
+  owned_critical_section(const owned_critical_section &);
+  owned_critical_section & operator=(const owned_critical_section &);
 };
 
 #endif /* CUBEB_UTILS_UNIX */
diff --git a/src/cubeb_utils_win.h b/src/cubeb_utils_win.h
index 0112ad6..4c47f45 100644
--- a/src/cubeb_utils_win.h
+++ b/src/cubeb_utils_win.h
@@ -8,26 +8,23 @@
 #if !defined(CUBEB_UTILS_WIN)
 #define CUBEB_UTILS_WIN
 
-#include <windows.h>
 #include "cubeb-internal.h"
+#include <windows.h>
 
 /* This wraps a critical section to track the owner in debug mode, adapted from
-   NSPR and http://blogs.msdn.com/b/oldnewthing/archive/2013/07/12/10433554.aspx */
-class owned_critical_section
-{
+   NSPR and http://blogs.msdn.com/b/oldnewthing/archive/2013/07/12/10433554.aspx
+ */
+class owned_critical_section {
 public:
   owned_critical_section()
 #ifndef NDEBUG
-    : owner(0)
+      : owner(0)
 #endif
   {
     InitializeCriticalSection(&critical_section);
   }
 
-  ~owned_critical_section()
-  {
-    DeleteCriticalSection(&critical_section);
-  }
+  ~owned_critical_section() { DeleteCriticalSection(&critical_section); }
 
   void lock()
   {
@@ -64,8 +61,8 @@ private:
 #endif
 
   // Disallow copy and assignment because CRICICAL_SECTION cannot be copied.
-  owned_critical_section(const owned_critical_section&);
-  owned_critical_section& operator=(const owned_critical_section&);
+  owned_critical_section(const owned_critical_section &);
+  owned_critical_section & operator=(const owned_critical_section &);
 };
 
 #endif /* CUBEB_UTILS_WIN */
diff --git a/src/cubeb_wasapi.cpp b/src/cubeb_wasapi.cpp
index 22a095a..0c794dc 100644
--- a/src/cubeb_wasapi.cpp
+++ b/src/cubeb_wasapi.cpp
@@ -7,85 +7,89 @@
 #define _WIN32_WINNT 0x0603
 #define NOMINMAX
 
-#include <initguid.h>
-#include <windows.h>
-#include <mmdeviceapi.h>
-#include <windef.h>
+#include <algorithm>
+#include <atomic>
 #include <audioclient.h>
+#include <avrt.h>
+#include <cmath>
 #include <devicetopology.h>
+#include <initguid.h>
+#include <limits>
+#include <memory>
+#include <mmdeviceapi.h>
 #include <process.h>
-#include <avrt.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <stdint.h>
-#include <cmath>
-#include <algorithm>
-#include <memory>
-#include <limits>
-#include <atomic>
 #include <vector>
+#include <windef.h>
+#include <windows.h>
 
-#include "cubeb/cubeb.h"
 #include "cubeb-internal.h"
+#include "cubeb/cubeb.h"
 #include "cubeb_mixer.h"
 #include "cubeb_resampler.h"
 #include "cubeb_strings.h"
 #include "cubeb_utils.h"
 
 // Windows 10 exposes the IAudioClient3 interface to create low-latency streams.
-// Copy the interface definition from audioclient.h here to make the code simpler
-// and so that we can still access IAudioClient3 via COM if cubeb was compiled
-// against an older SDK.
+// Copy the interface definition from audioclient.h here to make the code
+// simpler and so that we can still access IAudioClient3 via COM if cubeb was
+// compiled against an older SDK.
 #ifndef __IAudioClient3_INTERFACE_DEFINED__
 #define __IAudioClient3_INTERFACE_DEFINED__
 MIDL_INTERFACE("7ED4EE07-8E67-4CD4-8C1A-2B7A5987AD42")
 IAudioClient3 : public IAudioClient
 {
 public:
-    virtual HRESULT STDMETHODCALLTYPE GetSharedModeEnginePeriod(
-        /* [annotation][in] */
-        _In_  const WAVEFORMATEX *pFormat,
-        /* [annotation][out] */
-        _Out_  UINT32 *pDefaultPeriodInFrames,
-        /* [annotation][out] */
-        _Out_  UINT32 *pFundamentalPeriodInFrames,
-        /* [annotation][out] */
-        _Out_  UINT32 *pMinPeriodInFrames,
-        /* [annotation][out] */
-        _Out_  UINT32 *pMaxPeriodInFrames) = 0;
-
-    virtual HRESULT STDMETHODCALLTYPE GetCurrentSharedModeEnginePeriod(
-        /* [unique][annotation][out] */
-        _Out_  WAVEFORMATEX **ppFormat,
-        /* [annotation][out] */
-        _Out_  UINT32 *pCurrentPeriodInFrames) = 0;
-
-    virtual HRESULT STDMETHODCALLTYPE InitializeSharedAudioStream(
-        /* [annotation][in] */
-        _In_  DWORD StreamFlags,
-        /* [annotation][in] */
-        _In_  UINT32 PeriodInFrames,
-        /* [annotation][in] */
-        _In_  const WAVEFORMATEX *pFormat,
-        /* [annotation][in] */
-        _In_opt_  LPCGUID AudioSessionGuid) = 0;
+  virtual HRESULT STDMETHODCALLTYPE GetSharedModeEnginePeriod(
+      /* [annotation][in] */
+      _In_ const WAVEFORMATEX * pFormat,
+      /* [annotation][out] */
+      _Out_ UINT32 * pDefaultPeriodInFrames,
+      /* [annotation][out] */
+      _Out_ UINT32 * pFundamentalPeriodInFrames,
+      /* [annotation][out] */
+      _Out_ UINT32 * pMinPeriodInFrames,
+      /* [annotation][out] */
+      _Out_ UINT32 * pMaxPeriodInFrames) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE GetCurrentSharedModeEnginePeriod(
+      /* [unique][annotation][out] */
+      _Out_ WAVEFORMATEX * *ppFormat,
+      /* [annotation][out] */
+      _Out_ UINT32 * pCurrentPeriodInFrames) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE InitializeSharedAudioStream(
+      /* [annotation][in] */
+      _In_ DWORD StreamFlags,
+      /* [annotation][in] */
+      _In_ UINT32 PeriodInFrames,
+      /* [annotation][in] */
+      _In_ const WAVEFORMATEX * pFormat,
+      /* [annotation][in] */
+      _In_opt_ LPCGUID AudioSessionGuid) = 0;
 };
 #ifdef __CRT_UUID_DECL
 // Required for MinGW
-__CRT_UUID_DECL(IAudioClient3, 0x7ED4EE07, 0x8E67, 0x4CD4, 0x8C, 0x1A, 0x2B, 0x7A, 0x59, 0x87, 0xAD, 0x42)
+__CRT_UUID_DECL(IAudioClient3, 0x7ED4EE07, 0x8E67, 0x4CD4, 0x8C, 0x1A, 0x2B,
+                0x7A, 0x59, 0x87, 0xAD, 0x42)
 #endif
 #endif
 // Copied from audioclient.h in the Windows 10 SDK
 #ifndef AUDCLNT_E_ENGINE_PERIODICITY_LOCKED
-#define AUDCLNT_E_ENGINE_PERIODICITY_LOCKED    AUDCLNT_ERR(0x028)
+#define AUDCLNT_E_ENGINE_PERIODICITY_LOCKED AUDCLNT_ERR(0x028)
 #endif
 
 #ifndef PKEY_Device_FriendlyName
-DEFINE_PROPERTYKEY(PKEY_Device_FriendlyName,    0xa45c254e, 0xdf1c, 0x4efd, 0x80, 0x20, 0x67, 0xd1, 0x46, 0xa8, 0x50, 0xe0, 14);    // DEVPROP_TYPE_STRING
+DEFINE_PROPERTYKEY(PKEY_Device_FriendlyName, 0xa45c254e, 0xdf1c, 0x4efd, 0x80,
+                   0x20, 0x67, 0xd1, 0x46, 0xa8, 0x50, 0xe0,
+                   14); // DEVPROP_TYPE_STRING
 #endif
 #ifndef PKEY_Device_InstanceId
-DEFINE_PROPERTYKEY(PKEY_Device_InstanceId,      0x78c34fc8, 0x104a, 0x4aca, 0x9e, 0xa4, 0x52, 0x4d, 0x52, 0x99, 0x6e, 0x57, 0x00000100); //    VT_LPWSTR
+DEFINE_PROPERTYKEY(PKEY_Device_InstanceId, 0x78c34fc8, 0x104a, 0x4aca, 0x9e,
+                   0xa4, 0x52, 0x4d, 0x52, 0x99, 0x6e, 0x57,
+                   0x00000100); //    VT_LPWSTR
 #endif
 
 namespace {
@@ -93,29 +97,23 @@ namespace {
 const int64_t LATENCY_NOT_AVAILABLE_YET = -1;
 
 struct com_heap_ptr_deleter {
-  void operator()(void * ptr) const noexcept {
-    CoTaskMemFree(ptr);
-  }
+  void operator()(void * ptr) const noexcept { CoTaskMemFree(ptr); }
 };
 
 template <typename T>
 using com_heap_ptr = std::unique_ptr<T, com_heap_ptr_deleter>;
 
-template<typename T, size_t N>
-constexpr size_t
-ARRAY_LENGTH(T(&)[N])
+template <typename T, size_t N> constexpr size_t ARRAY_LENGTH(T (&)[N])
 {
   return N;
 }
 
-template <typename T>
-class no_addref_release : public T {
+template <typename T> class no_addref_release : public T {
   ULONG STDMETHODCALLTYPE AddRef() = 0;
   ULONG STDMETHODCALLTYPE Release() = 0;
 };
 
-template <typename T>
-class com_ptr {
+template <typename T> class com_ptr {
 public:
   com_ptr() noexcept = default;
 
@@ -123,17 +121,12 @@ public:
   com_ptr & operator=(com_ptr const & other) noexcept = delete;
   T ** operator&() const noexcept = delete;
 
-  ~com_ptr() noexcept {
-    release();
-  }
+  ~com_ptr() noexcept { release(); }
 
-  com_ptr(com_ptr && other) noexcept
-    : ptr(other.ptr)
-  {
-    other.ptr = nullptr;
-  }
+  com_ptr(com_ptr && other) noexcept : ptr(other.ptr) { other.ptr = nullptr; }
 
-  com_ptr & operator=(com_ptr && other) noexcept {
+  com_ptr & operator=(com_ptr && other) noexcept
+  {
     if (ptr != other.ptr) {
       release();
       ptr = other.ptr;
@@ -142,39 +135,41 @@ public:
     return *this;
   }
 
-  explicit operator bool() const noexcept {
-    return nullptr != ptr;
-  }
+  explicit operator bool() const noexcept { return nullptr != ptr; }
 
-  no_addref_release<T> * operator->() const noexcept {
+  no_addref_release<T> * operator->() const noexcept
+  {
     return static_cast<no_addref_release<T> *>(ptr);
   }
 
-  T * get() const noexcept {
-    return ptr;
-  }
+  T * get() const noexcept { return ptr; }
 
-  T ** receive() noexcept {
+  T ** receive() noexcept
+  {
     XASSERT(ptr == nullptr);
     return &ptr;
   }
 
-  void ** receive_vpp() noexcept {
+  void ** receive_vpp() noexcept
+  {
     return reinterpret_cast<void **>(receive());
   }
 
-  com_ptr & operator=(std::nullptr_t) noexcept {
+  com_ptr & operator=(std::nullptr_t) noexcept
+  {
     release();
     return *this;
   }
 
-  void reset(T * p = nullptr) noexcept {
+  void reset(T * p = nullptr) noexcept
+  {
     release();
     ptr = p;
   }
 
 private:
-  void release() noexcept {
+  void release() noexcept
+  {
     T * temp = ptr;
 
     if (temp) {
@@ -188,19 +183,33 @@ private:
 
 extern cubeb_ops const wasapi_ops;
 
-int wasapi_stream_stop(cubeb_stream * stm);
-int wasapi_stream_start(cubeb_stream * stm);
-void close_wasapi_stream(cubeb_stream * stm);
-int setup_wasapi_stream(cubeb_stream * stm);
-ERole pref_to_role(cubeb_stream_prefs param);
-int wasapi_create_device(cubeb * ctx, cubeb_device_info& ret, IMMDeviceEnumerator * enumerator, IMMDevice * dev);
-void wasapi_destroy_device(cubeb_device_info * device_info);
-static int wasapi_enumerate_devices(cubeb * context, cubeb_device_type type, cubeb_device_collection * out);
-static int wasapi_device_collection_destroy(cubeb * ctx, cubeb_device_collection * collection);
-static char const * wstr_to_utf8(wchar_t const * str);
-static std::unique_ptr<wchar_t const []> utf8_to_wstr(char const * str);
+int
+wasapi_stream_stop(cubeb_stream * stm);
+int
+wasapi_stream_start(cubeb_stream * stm);
+void
+close_wasapi_stream(cubeb_stream * stm);
+int
+setup_wasapi_stream(cubeb_stream * stm);
+ERole
+pref_to_role(cubeb_stream_prefs param);
+int
+wasapi_create_device(cubeb * ctx, cubeb_device_info & ret,
+                     IMMDeviceEnumerator * enumerator, IMMDevice * dev);
+void
+wasapi_destroy_device(cubeb_device_info * device_info);
+static int
+wasapi_enumerate_devices(cubeb * context, cubeb_device_type type,
+                         cubeb_device_collection * out);
+static int
+wasapi_device_collection_destroy(cubeb * ctx,
+                                 cubeb_device_collection * collection);
+static char const *
+wstr_to_utf8(wchar_t const * str);
+static std::unique_ptr<wchar_t const[]>
+utf8_to_wstr(char const * str);
 
-}
+} // namespace
 
 class wasapi_collection_notification_client;
 class monitor_device_notifications;
@@ -213,10 +222,12 @@ struct cubeb {
   com_ptr<IMMDeviceEnumerator> device_collection_enumerator;
   com_ptr<wasapi_collection_notification_client> collection_notification_client;
   /* Collection changed for input (capture) devices. */
-  cubeb_device_collection_changed_callback input_collection_changed_callback = nullptr;
+  cubeb_device_collection_changed_callback input_collection_changed_callback =
+      nullptr;
   void * input_collection_changed_user_ptr = nullptr;
   /* Collection changed for output (render) devices. */
-  cubeb_device_collection_changed_callback output_collection_changed_callback = nullptr;
+  cubeb_device_collection_changed_callback output_collection_changed_callback =
+      nullptr;
   void * output_collection_changed_user_ptr = nullptr;
   UINT64 performance_counter_frequency;
 };
@@ -241,12 +252,20 @@ struct cubeb_stream {
   /* Mixer pameters. We need to convert the input stream to this
      samplerate/channel layout, as WASAPI does not resample nor upmix
      itself. */
-  cubeb_stream_params input_mix_params = { CUBEB_SAMPLE_FLOAT32NE, 0, 0, CUBEB_LAYOUT_UNDEFINED, CUBEB_STREAM_PREF_NONE };
-  cubeb_stream_params output_mix_params = { CUBEB_SAMPLE_FLOAT32NE, 0, 0, CUBEB_LAYOUT_UNDEFINED, CUBEB_STREAM_PREF_NONE };
+  cubeb_stream_params input_mix_params = {CUBEB_SAMPLE_FLOAT32NE, 0, 0,
+                                          CUBEB_LAYOUT_UNDEFINED,
+                                          CUBEB_STREAM_PREF_NONE};
+  cubeb_stream_params output_mix_params = {CUBEB_SAMPLE_FLOAT32NE, 0, 0,
+                                           CUBEB_LAYOUT_UNDEFINED,
+                                           CUBEB_STREAM_PREF_NONE};
   /* Stream parameters. This is what the client requested,
    * and what will be presented in the callback. */
-  cubeb_stream_params input_stream_params = { CUBEB_SAMPLE_FLOAT32NE, 0, 0, CUBEB_LAYOUT_UNDEFINED, CUBEB_STREAM_PREF_NONE };
-  cubeb_stream_params output_stream_params = { CUBEB_SAMPLE_FLOAT32NE, 0, 0, CUBEB_LAYOUT_UNDEFINED, CUBEB_STREAM_PREF_NONE };
+  cubeb_stream_params input_stream_params = {CUBEB_SAMPLE_FLOAT32NE, 0, 0,
+                                             CUBEB_LAYOUT_UNDEFINED,
+                                             CUBEB_STREAM_PREF_NONE};
+  cubeb_stream_params output_stream_params = {CUBEB_SAMPLE_FLOAT32NE, 0, 0,
+                                              CUBEB_LAYOUT_UNDEFINED,
+                                              CUBEB_STREAM_PREF_NONE};
   /* A MMDevice role for this stream: either communication or console here. */
   ERole role;
   /* True if this stream will transport voice-data. */
@@ -326,10 +345,13 @@ struct cubeb_stream {
   /* Maximum number of frames that can be requested in a callback. */
   uint32_t output_buffer_frame_count = 0;
   /* Resampler instance. Resampling will only happen if necessary. */
-  std::unique_ptr<cubeb_resampler, decltype(&cubeb_resampler_destroy)> resampler = { nullptr, cubeb_resampler_destroy };
+  std::unique_ptr<cubeb_resampler, decltype(&cubeb_resampler_destroy)>
+      resampler = {nullptr, cubeb_resampler_destroy};
   /* Mixer interfaces */
-  std::unique_ptr<cubeb_mixer, decltype(&cubeb_mixer_destroy)> output_mixer = { nullptr, cubeb_mixer_destroy };
-  std::unique_ptr<cubeb_mixer, decltype(&cubeb_mixer_destroy)> input_mixer = { nullptr, cubeb_mixer_destroy };
+  std::unique_ptr<cubeb_mixer, decltype(&cubeb_mixer_destroy)> output_mixer = {
+      nullptr, cubeb_mixer_destroy};
+  std::unique_ptr<cubeb_mixer, decltype(&cubeb_mixer_destroy)> input_mixer = {
+      nullptr, cubeb_mixer_destroy};
   /* A buffer for up/down mixing multi-channel audio output. */
   std::vector<BYTE> mix_buffer;
   /* WASAPI input works in "packets". We re-linearize the audio packets
@@ -347,12 +369,13 @@ struct cubeb_stream {
   bool draining = false;
   /* True when we've destroyed the stream. This pointer is leaked on stream
    * destruction if we could not join the thread. */
-  std::atomic<std::atomic<bool>*> emergency_bailout { nullptr };
-  /* Synchronizes render thread start to ensure safe access to emergency_bailout. */
+  std::atomic<std::atomic<bool> *> emergency_bailout{nullptr};
+  /* Synchronizes render thread start to ensure safe access to
+   * emergency_bailout. */
   HANDLE thread_ready_event = 0;
   /* This needs an active audio input stream to be known, and is updated in the
    * first audio input callback. */
-  std::atomic<int64_t> input_latency_hns { LATENCY_NOT_AVAILABLE_YET };
+  std::atomic<int64_t> input_latency_hns{LATENCY_NOT_AVAILABLE_YET};
 
   /* Those attributes count the number of frames requested (resp. received) by
   the OS, to be able to detect drifts. This is only used for logging for now. */
@@ -362,8 +385,7 @@ struct cubeb_stream {
 
 class monitor_device_notifications {
 public:
-  monitor_device_notifications(cubeb * context)
-  : cubeb_context(context)
+  monitor_device_notifications(cubeb * context) : cubeb_context(context)
   {
     create_thread();
   }
@@ -397,12 +419,12 @@ public:
       }
     }
   }
+
 private:
-  static unsigned int __stdcall
-  thread_proc(LPVOID args)
+  static unsigned int __stdcall thread_proc(LPVOID args)
   {
     XASSERT(args);
-    auto mdn = static_cast<monitor_device_notifications*>(args);
+    auto mdn = static_cast<monitor_device_notifications *>(args);
     mdn->notification_thread_loop();
     SetEvent(mdn->shutdown_complete);
     return 0;
@@ -411,34 +433,31 @@ private:
   void notification_thread_loop()
   {
     struct auto_com {
-      auto_com() {
+      auto_com()
+      {
         HRESULT hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
         XASSERT(SUCCEEDED(hr));
       }
-      ~auto_com() {
-        CoUninitialize();
-      }
+      ~auto_com() { CoUninitialize(); }
     } com;
 
     HANDLE wait_array[3] = {
-      input_changed,
-      output_changed,
-      begin_shutdown,
+        input_changed,
+        output_changed,
+        begin_shutdown,
     };
 
     while (true) {
       Sleep(200);
 
       DWORD wait_result = WaitForMultipleObjects(ARRAY_LENGTH(wait_array),
-                                                 wait_array,
-                                                 FALSE,
-                                                 INFINITE);
+                                                 wait_array, FALSE, INFINITE);
       if (wait_result == WAIT_OBJECT_0) { // input changed
-        cubeb_context->input_collection_changed_callback(cubeb_context,
-          cubeb_context->input_collection_changed_user_ptr);
+        cubeb_context->input_collection_changed_callback(
+            cubeb_context, cubeb_context->input_collection_changed_user_ptr);
       } else if (wait_result == WAIT_OBJECT_0 + 1) { // output changed
-        cubeb_context->output_collection_changed_callback(cubeb_context,
-          cubeb_context->output_collection_changed_user_ptr);
+        cubeb_context->output_collection_changed_callback(
+            cubeb_context, cubeb_context->output_collection_changed_user_ptr);
       } else if (wait_result == WAIT_OBJECT_0 + 2) { // shutdown
         break;
       } else {
@@ -473,12 +492,8 @@ private:
       return;
     }
 
-    thread = (HANDLE) _beginthreadex(nullptr,
-                                     256 * 1024,
-                                     thread_proc,
-                                     this,
-                                     STACK_SIZE_PARAM_IS_A_RESERVATION,
-                                     nullptr);
+    thread = (HANDLE)_beginthreadex(nullptr, 256 * 1024, thread_proc, this,
+                                    STACK_SIZE_PARAM_IS_A_RESERVATION, nullptr);
     if (!thread) {
       LOG("Failed to create thread.");
       return;
@@ -494,18 +509,12 @@ private:
   cubeb * cubeb_context = nullptr;
 };
 
-class wasapi_collection_notification_client : public IMMNotificationClient
-{
+class wasapi_collection_notification_client : public IMMNotificationClient {
 public:
   /* The implementation of MSCOM was copied from MSDN. */
-  ULONG STDMETHODCALLTYPE
-  AddRef()
-  {
-    return InterlockedIncrement(&ref_count);
-  }
+  ULONG STDMETHODCALLTYPE AddRef() { return InterlockedIncrement(&ref_count); }
 
-  ULONG STDMETHODCALLTYPE
-  Release()
+  ULONG STDMETHODCALLTYPE Release()
   {
     ULONG ulRef = InterlockedDecrement(&ref_count);
     if (0 == ulRef) {
@@ -514,15 +523,14 @@ public:
     return ulRef;
   }
 
-  HRESULT STDMETHODCALLTYPE
-  QueryInterface(REFIID riid, VOID **ppvInterface)
+  HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, VOID ** ppvInterface)
   {
     if (__uuidof(IUnknown) == riid) {
       AddRef();
-      *ppvInterface = (IUnknown*)this;
+      *ppvInterface = (IUnknown *)this;
     } else if (__uuidof(IMMNotificationClient) == riid) {
       AddRef();
-      *ppvInterface = (IMMNotificationClient*)this;
+      *ppvInterface = (IMMNotificationClient *)this;
     } else {
       *ppvInterface = NULL;
       return E_NOINTERFACE;
@@ -531,18 +539,15 @@ public:
   }
 
   wasapi_collection_notification_client(cubeb * context)
-    : ref_count(1)
-    , cubeb_context(context)
-    , monitor_notifications(context)
+      : ref_count(1), cubeb_context(context), monitor_notifications(context)
   {
     XASSERT(cubeb_context);
   }
 
-  virtual ~wasapi_collection_notification_client()
-  { }
+  virtual ~wasapi_collection_notification_client() {}
 
-  HRESULT STDMETHODCALLTYPE
-  OnDefaultDeviceChanged(EDataFlow flow, ERole role, LPCWSTR device_id)
+  HRESULT STDMETHODCALLTYPE OnDefaultDeviceChanged(EDataFlow flow, ERole role,
+                                                   LPCWSTR device_id)
   {
     LOG("collection: Audio device default changed, id = %S.", device_id);
     return S_OK;
@@ -562,12 +567,13 @@ public:
     return S_OK;
   }
 
-  HRESULT STDMETHODCALLTYPE
-  OnDeviceStateChanged(LPCWSTR device_id, DWORD new_state)
+  HRESULT STDMETHODCALLTYPE OnDeviceStateChanged(LPCWSTR device_id,
+                                                 DWORD new_state)
   {
     XASSERT(cubeb_context->output_collection_changed_callback ||
             cubeb_context->input_collection_changed_callback);
-    LOG("collection: Audio device state changed, id = %S, state = %lu.", device_id, new_state);
+    LOG("collection: Audio device state changed, id = %S, state = %lu.",
+        device_id, new_state);
     EDataFlow flow;
     HRESULT hr = GetDataFlow(device_id, &flow);
     if (FAILED(hr)) {
@@ -577,10 +583,10 @@ public:
     return S_OK;
   }
 
-  HRESULT STDMETHODCALLTYPE
-  OnPropertyValueChanged(LPCWSTR device_id, const PROPERTYKEY key)
+  HRESULT STDMETHODCALLTYPE OnPropertyValueChanged(LPCWSTR device_id,
+                                                   const PROPERTYKEY key)
   {
-    //Audio device property value changed.
+    // Audio device property value changed.
     return S_OK;
   }
 
@@ -590,8 +596,8 @@ private:
     com_ptr<IMMDevice> device;
     com_ptr<IMMEndpoint> endpoint;
 
-    HRESULT hr = cubeb_context->device_collection_enumerator
-                   ->GetDevice(device_id, device.receive());
+    HRESULT hr = cubeb_context->device_collection_enumerator->GetDevice(
+        device_id, device.receive());
     if (FAILED(hr)) {
       LOG("collection: Could not get device: %lx", hr);
       return hr;
@@ -613,18 +619,12 @@ private:
   monitor_device_notifications monitor_notifications;
 };
 
-class wasapi_endpoint_notification_client : public IMMNotificationClient
-{
+class wasapi_endpoint_notification_client : public IMMNotificationClient {
 public:
   /* The implementation of MSCOM was copied from MSDN. */
-  ULONG STDMETHODCALLTYPE
-  AddRef()
-  {
-    return InterlockedIncrement(&ref_count);
-  }
+  ULONG STDMETHODCALLTYPE AddRef() { return InterlockedIncrement(&ref_count); }
 
-  ULONG STDMETHODCALLTYPE
-  Release()
+  ULONG STDMETHODCALLTYPE Release()
   {
     ULONG ulRef = InterlockedDecrement(&ref_count);
     if (0 == ulRef) {
@@ -633,15 +633,14 @@ public:
     return ulRef;
   }
 
-  HRESULT STDMETHODCALLTYPE
-  QueryInterface(REFIID riid, VOID **ppvInterface)
+  HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, VOID ** ppvInterface)
   {
     if (__uuidof(IUnknown) == riid) {
       AddRef();
-      *ppvInterface = (IUnknown*)this;
+      *ppvInterface = (IUnknown *)this;
     } else if (__uuidof(IMMNotificationClient) == riid) {
       AddRef();
-      *ppvInterface = (IMMNotificationClient*)this;
+      *ppvInterface = (IMMNotificationClient *)this;
     } else {
       *ppvInterface = NULL;
       return E_NOINTERFACE;
@@ -650,16 +649,14 @@ public:
   }
 
   wasapi_endpoint_notification_client(HANDLE event, ERole role)
-    : ref_count(1)
-    , reconfigure_event(event)
-    , role(role)
-  { }
+      : ref_count(1), reconfigure_event(event), role(role)
+  {
+  }
 
-  virtual ~wasapi_endpoint_notification_client()
-  { }
+  virtual ~wasapi_endpoint_notification_client() {}
 
-  HRESULT STDMETHODCALLTYPE
-  OnDefaultDeviceChanged(EDataFlow flow, ERole role, LPCWSTR device_id)
+  HRESULT STDMETHODCALLTYPE OnDefaultDeviceChanged(EDataFlow flow, ERole role,
+                                                   LPCWSTR device_id)
   {
     LOG("endpoint: Audio device default changed.");
 
@@ -670,7 +667,8 @@ public:
 
     BOOL ok = SetEvent(reconfigure_event);
     if (!ok) {
-      LOG("endpoint: SetEvent on reconfigure_event failed: %lx", GetLastError());
+      LOG("endpoint: SetEvent on reconfigure_event failed: %lx",
+          GetLastError());
     }
 
     return S_OK;
@@ -690,19 +688,20 @@ public:
     return S_OK;
   }
 
-  HRESULT STDMETHODCALLTYPE
-  OnDeviceStateChanged(LPCWSTR device_id, DWORD new_state)
+  HRESULT STDMETHODCALLTYPE OnDeviceStateChanged(LPCWSTR device_id,
+                                                 DWORD new_state)
   {
     LOG("endpoint: Audio device state changed.");
     return S_OK;
   }
 
-  HRESULT STDMETHODCALLTYPE
-  OnPropertyValueChanged(LPCWSTR device_id, const PROPERTYKEY key)
+  HRESULT STDMETHODCALLTYPE OnPropertyValueChanged(LPCWSTR device_id,
+                                                   const PROPERTYKEY key)
   {
-    //Audio device property value changed.
+    // Audio device property value changed.
     return S_OK;
   }
+
 private:
   /* refcount for this instance, necessary to implement MSCOM semantics. */
   LONG ref_count;
@@ -724,28 +723,34 @@ intern_device_id(cubeb * ctx, wchar_t const * id)
 
   char const * interned = cubeb_strings_intern(ctx->device_ids, tmp);
 
-  free((void *) tmp);
+  free((void *)tmp);
 
   return interned;
 }
 
-bool has_input(cubeb_stream * stm)
+bool
+has_input(cubeb_stream * stm)
 {
   return stm->input_stream_params.rate != 0;
 }
 
-bool has_output(cubeb_stream * stm)
+bool
+has_output(cubeb_stream * stm)
 {
   return stm->output_stream_params.rate != 0;
 }
 
-double stream_to_mix_samplerate_ratio(cubeb_stream_params & stream, cubeb_stream_params & mixer)
+double
+stream_to_mix_samplerate_ratio(cubeb_stream_params & stream,
+                               cubeb_stream_params & mixer)
 {
   return double(stream.rate) / mixer.rate;
 }
 
 /* Convert the channel layout into the corresponding KSAUDIO_CHANNEL_CONFIG.
-   See more: https://msdn.microsoft.com/en-us/library/windows/hardware/ff537083(v=vs.85).aspx */
+   See more:
+   https://msdn.microsoft.com/en-us/library/windows/hardware/ff537083(v=vs.85).aspx
+ */
 
 cubeb_channel_layout
 mask_to_channel_layout(WAVEFORMATEX const * fmt)
@@ -753,7 +758,8 @@ mask_to_channel_layout(WAVEFORMATEX const * fmt)
   cubeb_channel_layout mask = 0;
 
   if (fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE) {
-    WAVEFORMATEXTENSIBLE const * ext = reinterpret_cast<WAVEFORMATEXTENSIBLE const *>(fmt);
+    WAVEFORMATEXTENSIBLE const * ext =
+        reinterpret_cast<WAVEFORMATEXTENSIBLE const *>(fmt);
     mask = ext->dwChannelMask;
   } else if (fmt->wFormatTag == WAVE_FORMAT_PCM ||
              fmt->wFormatTag == WAVE_FORMAT_IEEE_FLOAT) {
@@ -820,11 +826,9 @@ refill(cubeb_stream * stm, void * input_buffer, long input_frames_count,
     }
   }
 
-  long out_frames = cubeb_resampler_fill(stm->resampler.get(),
-                                         input_buffer,
-                                         &input_frames_count,
-                                         dest,
-                                         output_frames_needed);
+  long out_frames =
+      cubeb_resampler_fill(stm->resampler.get(), input_buffer,
+                           &input_frames_count, dest, output_frames_needed);
   /* TODO: Report out_frames < 0 as an error via the API. */
   XASSERT(out_frames >= 0);
 
@@ -846,7 +850,8 @@ refill(cubeb_stream * stm, void * input_buffer, long input_frames_count,
 
   /* If this is not true, there will be glitches.
      It is alright to have produced less frames if we are draining, though. */
-  XASSERT(out_frames == output_frames_needed || stm->draining || !has_output(stm) || stm->has_dummy_output);
+  XASSERT(out_frames == output_frames_needed || stm->draining ||
+          !has_output(stm) || stm->has_dummy_output);
 
 #ifndef CUBEB_WASAPI_USE_IAUDIOSTREAMVOLUME
   if (has_output(stm) && !stm->has_dummy_output && volume != 1.0) {
@@ -878,20 +883,17 @@ refill(cubeb_stream * stm, void * input_buffer, long input_frames_count,
   }
 #endif
 
-  // We don't bother mixing dummy output as it will be silenced, otherwise mix output if needed
+  // We don't bother mixing dummy output as it will be silenced, otherwise mix
+  // output if needed
   if (!stm->has_dummy_output && has_output(stm) && stm->output_mixer) {
     XASSERT(dest == stm->mix_buffer.data());
     size_t dest_size =
-      out_frames * stm->output_stream_params.channels * stm->bytes_per_sample;
+        out_frames * stm->output_stream_params.channels * stm->bytes_per_sample;
     XASSERT(dest_size <= stm->mix_buffer.size());
     size_t output_buffer_size =
-      out_frames * stm->output_mix_params.channels * stm->bytes_per_sample;
-    int ret = cubeb_mixer_mix(stm->output_mixer.get(),
-                              out_frames,
-                              dest,
-                              dest_size,
-                              output_buffer,
-                              output_buffer_size);
+        out_frames * stm->output_mix_params.channels * stm->bytes_per_sample;
+    int ret = cubeb_mixer_mix(stm->output_mixer.get(), out_frames, dest,
+                              dest_size, output_buffer, output_buffer_size);
     if (ret < 0) {
       LOG("Error remixing content (%d)", ret);
     }
@@ -900,7 +902,8 @@ refill(cubeb_stream * stm, void * input_buffer, long input_frames_count,
   return out_frames;
 }
 
-int trigger_async_reconfigure(cubeb_stream * stm)
+int
+trigger_async_reconfigure(cubeb_stream * stm)
 {
   XASSERT(stm && stm->reconfigure_event);
   BOOL ok = SetEvent(stm->reconfigure_event);
@@ -911,10 +914,11 @@ int trigger_async_reconfigure(cubeb_stream * stm)
   return CUBEB_OK;
 }
 
-
 /* This helper grabs all the frames available from a capture client, put them in
- * the linear_input_buffer.  This helper does not work with exclusive mode streams. */
-bool get_input_buffer(cubeb_stream * stm)
+ * the linear_input_buffer.  This helper does not work with exclusive mode
+ * streams. */
+bool
+get_input_buffer(cubeb_stream * stm)
 {
   XASSERT(has_input(stm));
 
@@ -931,8 +935,7 @@ bool get_input_buffer(cubeb_stream * stm)
   // single packet each time. However, if we're pulling from the stream we may
   // need to grab multiple packets worth of frames that have accumulated (so
   // need a loop).
-  for (hr = stm->capture_client->GetNextPacketSize(&next);
-       next > 0;
+  for (hr = stm->capture_client->GetNextPacketSize(&next); next > 0;
        hr = stm->capture_client->GetNextPacketSize(&next)) {
     if (hr == AUDCLNT_E_DEVICE_INVALIDATED) {
       // Application can recover from this error. More info
@@ -948,11 +951,8 @@ bool get_input_buffer(cubeb_stream * stm)
     }
 
     UINT32 frames;
-    hr = stm->capture_client->GetBuffer(&input_packet,
-                                        &frames,
-                                        &flags,
-                                        &dev_pos,
-                                        &pc_position);
+    hr = stm->capture_client->GetBuffer(&input_packet, &frames, &flags,
+                                        &dev_pos, &pc_position);
 
     if (FAILED(hr)) {
       LOG("GetBuffer failed for capture: %lx", hr);
@@ -963,9 +963,12 @@ bool get_input_buffer(cubeb_stream * stm)
     if (stm->context->performance_counter_frequency) {
       LARGE_INTEGER now;
       UINT64 now_hns;
-      // See https://docs.microsoft.com/en-us/windows/win32/api/audioclient/nf-audioclient-iaudiocaptureclient-getbuffer, section "Remarks".
+      // See
+      // https://docs.microsoft.com/en-us/windows/win32/api/audioclient/nf-audioclient-iaudiocaptureclient-getbuffer,
+      // section "Remarks".
       QueryPerformanceCounter(&now);
-      now_hns = 10000000 * now.QuadPart / stm->context->performance_counter_frequency;
+      now_hns =
+          10000000 * now.QuadPart / stm->context->performance_counter_frequency;
       if (now_hns >= pc_position) {
         stm->input_latency_hns = now_hns - pc_position;
       }
@@ -984,10 +987,12 @@ bool get_input_buffer(cubeb_stream * stm)
     //     stream to drive input in the case of input only loopback. Without
     //     a dummy output, input only loopback would glitch on silence. However,
     //     the dummy input should push silence to the loopback and prevent
-    //     discontinuities. See https://blogs.msdn.microsoft.com/matthew_van_eerde/2008/12/16/sample-wasapi-loopback-capture-record-what-you-hear/
+    //     discontinuities. See
+    //     https://blogs.msdn.microsoft.com/matthew_van_eerde/2008/12/16/sample-wasapi-loopback-capture-record-what-you-hear/
     // As the first scenario can be ignored, and we anticipate the second
     // scenario is mitigated, we ignore the flag.
-    // For more info: https://msdn.microsoft.com/en-us/library/windows/desktop/dd370859(v=vs.85).aspx,
+    // For more info:
+    // https://msdn.microsoft.com/en-us/library/windows/desktop/dd370859(v=vs.85).aspx,
     // https://msdn.microsoft.com/en-us/library/windows/desktop/dd371458(v=vs.85).aspx
     if (flags & AUDCLNT_BUFFERFLAGS_SILENT) {
       LOG("insert silence: ps=%u", frames);
@@ -995,25 +1000,21 @@ bool get_input_buffer(cubeb_stream * stm)
     } else {
       if (stm->input_mixer) {
         bool ok = stm->linear_input_buffer->reserve(
-          stm->linear_input_buffer->length() + input_stream_samples);
+            stm->linear_input_buffer->length() + input_stream_samples);
         XASSERT(ok);
         size_t input_packet_size =
-          frames * stm->input_mix_params.channels *
-          cubeb_sample_size(stm->input_mix_params.format);
+            frames * stm->input_mix_params.channels *
+            cubeb_sample_size(stm->input_mix_params.format);
         size_t linear_input_buffer_size =
-          input_stream_samples *
-          cubeb_sample_size(stm->input_stream_params.format);
-        cubeb_mixer_mix(stm->input_mixer.get(),
-                        frames,
-                        input_packet,
-                        input_packet_size,
-                        stm->linear_input_buffer->end(),
+            input_stream_samples *
+            cubeb_sample_size(stm->input_stream_params.format);
+        cubeb_mixer_mix(stm->input_mixer.get(), frames, input_packet,
+                        input_packet_size, stm->linear_input_buffer->end(),
                         linear_input_buffer_size);
         stm->linear_input_buffer->set_length(
-          stm->linear_input_buffer->length() + input_stream_samples);
+            stm->linear_input_buffer->length() + input_stream_samples);
       } else {
-        stm->linear_input_buffer->push(
-          input_packet, input_stream_samples);
+        stm->linear_input_buffer->push(input_packet, input_stream_samples);
       }
     }
     hr = stm->capture_client->ReleaseBuffer(frames);
@@ -1033,7 +1034,8 @@ bool get_input_buffer(cubeb_stream * stm)
 
 /* Get an output buffer from the render_client. It has to be released before
  * exiting the callback. */
-bool get_output_buffer(cubeb_stream * stm, void *& buffer, size_t & frame_count)
+bool
+get_output_buffer(cubeb_stream * stm, void *& buffer, size_t & frame_count)
 {
   UINT32 padding_out;
   HRESULT hr;
@@ -1042,11 +1044,11 @@ bool get_output_buffer(cubeb_stream * stm, void *& buffer, size_t & frame_count)
 
   hr = stm->output_client->GetCurrentPadding(&padding_out);
   if (hr == AUDCLNT_E_DEVICE_INVALIDATED) {
-      // Application can recover from this error. More info
-      // https://msdn.microsoft.com/en-us/library/windows/desktop/dd316605(v=vs.85).aspx
-      LOG("Device invalidated error, reset default device");
-      trigger_async_reconfigure(stm);
-      return true;
+    // Application can recover from this error. More info
+    // https://msdn.microsoft.com/en-us/library/windows/desktop/dd316605(v=vs.85).aspx
+    LOG("Device invalidated error, reset default device");
+    trigger_async_reconfigure(stm);
+    return true;
   }
 
   if (FAILED(hr)) {
@@ -1101,7 +1103,8 @@ refill_callback_duplex(cubeb_stream * stm)
     }
   }
 
-  input_frames = stm->linear_input_buffer->length() / stm->input_stream_params.channels;
+  input_frames =
+      stm->linear_input_buffer->length() / stm->input_stream_params.channels;
 
   rv = get_output_buffer(stm, output_buffer, output_frames);
   if (!rv) {
@@ -1122,30 +1125,24 @@ refill_callback_duplex(cubeb_stream * stm)
 
   stm->total_output_frames += output_frames;
 
-  ALOGV("in: %zu, out: %zu, missing: %ld, ratio: %f",
-        stm->total_input_frames, stm->total_output_frames,
+  ALOGV("in: %zu, out: %zu, missing: %ld, ratio: %f", stm->total_input_frames,
+        stm->total_output_frames,
         static_cast<long>(stm->total_output_frames) - stm->total_input_frames,
         static_cast<float>(stm->total_output_frames) / stm->total_input_frames);
 
   if (stm->has_dummy_output) {
-    ALOGV("Duplex callback (dummy output): input frames: %Iu, output frames: %Iu",
-          input_frames, output_frames);
+    ALOGV(
+        "Duplex callback (dummy output): input frames: %Iu, output frames: %Iu",
+        input_frames, output_frames);
 
     // We don't want to expose the dummy output to the callback so don't pass
     // the output buffer (it will be released later with silence in it)
-    refill(stm,
-           stm->linear_input_buffer->data(),
-           input_frames,
-           nullptr,
-           0);
+    refill(stm, stm->linear_input_buffer->data(), input_frames, nullptr, 0);
   } else {
     ALOGV("Duplex callback: input frames: %Iu, output frames: %Iu",
           input_frames, output_frames);
 
-    refill(stm,
-           stm->linear_input_buffer->data(),
-           input_frames,
-           output_buffer,
+    refill(stm, stm->linear_input_buffer->data(), input_frames, output_buffer,
            output_frames);
   }
 
@@ -1153,7 +1150,8 @@ refill_callback_duplex(cubeb_stream * stm)
 
   if (stm->has_dummy_output) {
     // If output is a dummy output, make sure it's silent
-    hr = stm->render_client->ReleaseBuffer(output_frames, AUDCLNT_BUFFERFLAGS_SILENT);
+    hr = stm->render_client->ReleaseBuffer(output_frames,
+                                           AUDCLNT_BUFFERFLAGS_SILENT);
   } else {
     hr = stm->render_client->ReleaseBuffer(output_frames, 0);
   }
@@ -1177,18 +1175,16 @@ refill_callback_input(cubeb_stream * stm)
     return rv;
   }
 
-  input_frames = stm->linear_input_buffer->length() / stm->input_stream_params.channels;
+  input_frames =
+      stm->linear_input_buffer->length() / stm->input_stream_params.channels;
   if (!input_frames) {
     return true;
   }
 
   ALOGV("Input callback: input frames: %Iu", input_frames);
 
-  long read = refill(stm,
-                     stm->linear_input_buffer->data(),
-                     input_frames,
-                     nullptr,
-                     0);
+  long read =
+      refill(stm, stm->linear_input_buffer->data(), input_frames, nullptr, 0);
 
   XASSERT(read >= 0);
 
@@ -1216,14 +1212,10 @@ refill_callback_output(cubeb_stream * stm)
     return true;
   }
 
-  long got = refill(stm,
-                    nullptr,
-                    0,
-                    output_buffer,
-                    output_frames);
+  long got = refill(stm, nullptr, 0, output_buffer, output_frames);
 
-  ALOGV("Output callback: output frames requested: %Iu, got %ld",
-        output_frames, got);
+  ALOGV("Output callback: output frames requested: %Iu, got %ld", output_frames,
+        got);
 
   XASSERT(got >= 0);
   XASSERT(size_t(got) == output_frames || stm->draining);
@@ -1237,8 +1229,7 @@ refill_callback_output(cubeb_stream * stm)
   return size_t(got) == output_frames || stm->draining;
 }
 
-static unsigned int __stdcall
-wasapi_stream_render_loop(LPVOID stream)
+static unsigned int __stdcall wasapi_stream_render_loop(LPVOID stream)
 {
   cubeb_stream * stm = static_cast<cubeb_stream *>(stream);
   std::atomic<bool> * emergency_bailout = stm->emergency_bailout;
@@ -1251,23 +1242,18 @@ wasapi_stream_render_loop(LPVOID stream)
   }
 
   bool is_playing = true;
-  HANDLE wait_array[4] = {
-    stm->shutdown_event,
-    stm->reconfigure_event,
-    stm->refill_event,
-    stm->input_available_event
-  };
+  HANDLE wait_array[4] = {stm->shutdown_event, stm->reconfigure_event,
+                          stm->refill_event, stm->input_available_event};
   HANDLE mmcss_handle = NULL;
   HRESULT hr = 0;
   DWORD mmcss_task_index = 0;
   struct auto_com {
-    auto_com() {
+    auto_com()
+    {
       HRESULT hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
       XASSERT(SUCCEEDED(hr));
     }
-    ~auto_com() {
-      CoUninitialize();
-    }
+    ~auto_com() { CoUninitialize(); }
   } com;
 
   /* We could consider using "Pro Audio" here for WebAudio and
@@ -1275,7 +1261,8 @@ wasapi_stream_render_loop(LPVOID stream)
   mmcss_handle = AvSetMmThreadCharacteristicsA("Audio", &mmcss_task_index);
   if (!mmcss_handle) {
     /* This is not fatal, but we might glitch under heavy load. */
-    LOG("Unable to use mmcss to bump the render thread priority: %lx", GetLastError());
+    LOG("Unable to use mmcss to bump the render thread priority: %lx",
+        GetLastError());
   }
 
   /* WaitForMultipleObjects timeout can trigger in cases where we don't want to
@@ -1286,16 +1273,15 @@ wasapi_stream_render_loop(LPVOID stream)
   const unsigned timeout_limit = 3;
   while (is_playing) {
     // We want to check the emergency bailout variable before a
-    // and after the WaitForMultipleObject, because the handles WaitForMultipleObjects
-    // is going to wait on might have been closed already.
+    // and after the WaitForMultipleObject, because the handles
+    // WaitForMultipleObjects is going to wait on might have been closed
+    // already.
     if (*emergency_bailout) {
       delete emergency_bailout;
       return 0;
     }
     DWORD waitResult = WaitForMultipleObjects(ARRAY_LENGTH(wait_array),
-                                              wait_array,
-                                              FALSE,
-                                              1000);
+                                              wait_array, FALSE, 1000);
     if (*emergency_bailout) {
       delete emergency_bailout;
       return 0;
@@ -1329,8 +1315,8 @@ wasapi_stream_render_loop(LPVOID stream)
         auto_lock lock(stm->stream_reset_lock);
         close_wasapi_stream(stm);
         LOG("Stream closed.");
-        /* Reopen a stream and start it immediately. This will automatically pick the
-           new default device for this role. */
+        /* Reopen a stream and start it immediately. This will automatically
+           pick the new default device for this role. */
         int r = setup_wasapi_stream(stm);
         if (r != CUBEB_OK) {
           LOG("Error setting up the stream during reconfigure.");
@@ -1363,7 +1349,7 @@ wasapi_stream_render_loop(LPVOID stream)
       }
       break;
     }
-    case WAIT_OBJECT_0 + 2:  /* refill */
+    case WAIT_OBJECT_0 + 2: /* refill */
       XASSERT((has_input(stm) && has_output(stm)) ||
               (!has_input(stm) && has_output(stm)));
       is_playing = stm->refill_callback(stm);
@@ -1405,15 +1391,19 @@ wasapi_stream_render_loop(LPVOID stream)
   return 0;
 }
 
-void wasapi_destroy(cubeb * context);
+void
+wasapi_destroy(cubeb * context);
 
-HRESULT register_notification_client(cubeb_stream * stm)
+HRESULT
+register_notification_client(cubeb_stream * stm)
 {
   XASSERT(stm->device_enumerator);
 
-  stm->notification_client.reset(new wasapi_endpoint_notification_client(stm->reconfigure_event, stm->role));
+  stm->notification_client.reset(new wasapi_endpoint_notification_client(
+      stm->reconfigure_event, stm->role));
 
-  HRESULT hr = stm->device_enumerator->RegisterEndpointNotificationCallback(stm->notification_client.get());
+  HRESULT hr = stm->device_enumerator->RegisterEndpointNotificationCallback(
+      stm->notification_client.get());
   if (FAILED(hr)) {
     LOG("Could not register endpoint notification callback: %lx", hr);
     stm->notification_client = nullptr;
@@ -1422,11 +1412,13 @@ HRESULT register_notification_client(cubeb_stream * stm)
   return hr;
 }
 
-HRESULT unregister_notification_client(cubeb_stream * stm)
+HRESULT
+unregister_notification_client(cubeb_stream * stm)
 {
   XASSERT(stm->device_enumerator);
 
-  HRESULT hr = stm->device_enumerator->UnregisterEndpointNotificationCallback(stm->notification_client.get());
+  HRESULT hr = stm->device_enumerator->UnregisterEndpointNotificationCallback(
+      stm->notification_client.get());
   if (FAILED(hr)) {
     // We can't really do anything here, we'll probably leak the
     // notification client.
@@ -1438,12 +1430,13 @@ HRESULT unregister_notification_client(cubeb_stream * stm)
   return S_OK;
 }
 
-HRESULT get_endpoint(com_ptr<IMMDevice> & device, LPCWSTR devid)
+HRESULT
+get_endpoint(com_ptr<IMMDevice> & device, LPCWSTR devid)
 {
   com_ptr<IMMDeviceEnumerator> enumerator;
-  HRESULT hr = CoCreateInstance(__uuidof(MMDeviceEnumerator),
-                                NULL, CLSCTX_INPROC_SERVER,
-                                IID_PPV_ARGS(enumerator.receive()));
+  HRESULT hr =
+      CoCreateInstance(__uuidof(MMDeviceEnumerator), NULL, CLSCTX_INPROC_SERVER,
+                       IID_PPV_ARGS(enumerator.receive()));
   if (FAILED(hr)) {
     LOG("Could not get device enumerator: %lx", hr);
     return hr;
@@ -1458,20 +1451,23 @@ HRESULT get_endpoint(com_ptr<IMMDevice> & device, LPCWSTR devid)
   return S_OK;
 }
 
-HRESULT register_collection_notification_client(cubeb * context)
+HRESULT
+register_collection_notification_client(cubeb * context)
 {
-  HRESULT hr = CoCreateInstance(__uuidof(MMDeviceEnumerator),
-                                NULL, CLSCTX_INPROC_SERVER,
-                                IID_PPV_ARGS(context->device_collection_enumerator.receive()));
+  HRESULT hr = CoCreateInstance(
+      __uuidof(MMDeviceEnumerator), NULL, CLSCTX_INPROC_SERVER,
+      IID_PPV_ARGS(context->device_collection_enumerator.receive()));
   if (FAILED(hr)) {
     LOG("Could not get device enumerator: %lx", hr);
     return hr;
   }
 
-  context->collection_notification_client.reset(new wasapi_collection_notification_client(context));
+  context->collection_notification_client.reset(
+      new wasapi_collection_notification_client(context));
 
-  hr = context->device_collection_enumerator->RegisterEndpointNotificationCallback(
-                                                context->collection_notification_client.get());
+  hr = context->device_collection_enumerator
+           ->RegisterEndpointNotificationCallback(
+               context->collection_notification_client.get());
   if (FAILED(hr)) {
     LOG("Could not register endpoint notification callback: %lx", hr);
     context->collection_notification_client.reset();
@@ -1481,10 +1477,12 @@ HRESULT register_collection_notification_client(cubeb * context)
   return hr;
 }
 
-HRESULT unregister_collection_notification_client(cubeb * context)
+HRESULT
+unregister_collection_notification_client(cubeb * context)
 {
-  HRESULT hr = context->device_collection_enumerator->
-    UnregisterEndpointNotificationCallback(context->collection_notification_client.get());
+  HRESULT hr = context->device_collection_enumerator
+                   ->UnregisterEndpointNotificationCallback(
+                       context->collection_notification_client.get());
   if (FAILED(hr)) {
     return hr;
   }
@@ -1495,12 +1493,14 @@ HRESULT unregister_collection_notification_client(cubeb * context)
   return hr;
 }
 
-HRESULT get_default_endpoint(com_ptr<IMMDevice> & device, EDataFlow direction, ERole role)
+HRESULT
+get_default_endpoint(com_ptr<IMMDevice> & device, EDataFlow direction,
+                     ERole role)
 {
   com_ptr<IMMDeviceEnumerator> enumerator;
-  HRESULT hr = CoCreateInstance(__uuidof(MMDeviceEnumerator),
-                                NULL, CLSCTX_INPROC_SERVER,
-                                IID_PPV_ARGS(enumerator.receive()));
+  HRESULT hr =
+      CoCreateInstance(__uuidof(MMDeviceEnumerator), NULL, CLSCTX_INPROC_SERVER,
+                       IID_PPV_ARGS(enumerator.receive()));
   if (FAILED(hr)) {
     LOG("Could not get device enumerator: %lx", hr);
     return hr;
@@ -1541,7 +1541,8 @@ current_stream_delay(cubeb_stream * stm)
   }
 
   double cur_pos = static_cast<double>(pos) / freq;
-  double max_pos = static_cast<double>(stm->frames_written)  / stm->output_mix_params.rate;
+  double max_pos =
+      static_cast<double>(stm->frames_written) / stm->output_mix_params.rate;
   double delay = std::max(max_pos - cur_pos, 0.0);
 
   return delay;
@@ -1574,7 +1575,7 @@ stream_set_volume(cubeb_stream * stm, float volume)
     volumes[i] = volume;
   }
 
-  hr = stm->audio_stream_volume->SetAllVolumes(channels,  volumes);
+  hr = stm->audio_stream_volume->SetAllVolumes(channels, volumes);
   if (FAILED(hr)) {
     LOG("could not set the channels volume: %lx", hr);
     return CUBEB_ERROR;
@@ -1583,10 +1584,11 @@ stream_set_volume(cubeb_stream * stm, float volume)
   return CUBEB_OK;
 }
 #endif
-} // namespace anonymous
+} // namespace
 
 extern "C" {
-int wasapi_init(cubeb ** context, char const * context_name)
+int
+wasapi_init(cubeb ** context, char const * context_name)
 {
   /* We don't use the device yet, but need to make sure we can initialize one
      so that this backend is not incorrectly enabled on platforms that don't
@@ -1615,7 +1617,8 @@ int wasapi_init(cubeb ** context, char const * context_name)
   if (QueryPerformanceFrequency(&frequency)) {
     ctx->performance_counter_frequency = frequency.QuadPart;
   } else {
-    LOG("Failed getting performance counter frequency, latency reporting will be inacurate");
+    LOG("Failed getting performance counter frequency, latency reporting will "
+        "be inacurate");
     ctx->performance_counter_frequency = 0;
   }
 
@@ -1626,7 +1629,8 @@ int wasapi_init(cubeb ** context, char const * context_name)
 }
 
 namespace {
-bool stop_and_join_render_thread(cubeb_stream * stm)
+bool
+stop_and_join_render_thread(cubeb_stream * stm)
 {
   bool rv = true;
   LOG("Stop and join render thread.");
@@ -1655,7 +1659,8 @@ bool stop_and_join_render_thread(cubeb_stream * stm)
     *(stm->emergency_bailout) = true;
     // We give the ownership to the rendering thread.
     stm->emergency_bailout = nullptr;
-    LOG("Destroy WaitForSingleObject on thread failed: %lx, %lx", r, GetLastError());
+    LOG("Destroy WaitForSingleObject on thread failed: %lx, %lx", r,
+        GetLastError());
     rv = false;
   }
 
@@ -1674,7 +1679,8 @@ bool stop_and_join_render_thread(cubeb_stream * stm)
   return rv;
 }
 
-void wasapi_destroy(cubeb * context)
+void
+wasapi_destroy(cubeb * context)
 {
   if (context->device_ids) {
     cubeb_strings_destroy(context->device_ids);
@@ -1683,7 +1689,8 @@ void wasapi_destroy(cubeb * context)
   delete context;
 }
 
-char const * wasapi_get_backend_id(cubeb * context)
+char const *
+wasapi_get_backend_id(cubeb * context)
 {
   return "wasapi";
 }
@@ -1700,9 +1707,8 @@ wasapi_get_max_channel_count(cubeb * ctx, uint32_t * max_channels)
   }
 
   com_ptr<IAudioClient> client;
-  hr = device->Activate(__uuidof(IAudioClient),
-                        CLSCTX_INPROC_SERVER,
-                        NULL, client.receive_vpp());
+  hr = device->Activate(__uuidof(IAudioClient), CLSCTX_INPROC_SERVER, NULL,
+                        client.receive_vpp());
   if (FAILED(hr)) {
     return CUBEB_ERROR;
   }
@@ -1720,9 +1726,11 @@ wasapi_get_max_channel_count(cubeb * ctx, uint32_t * max_channels)
 }
 
 int
-wasapi_get_min_latency(cubeb * ctx, cubeb_stream_params params, uint32_t * latency_frames)
+wasapi_get_min_latency(cubeb * ctx, cubeb_stream_params params,
+                       uint32_t * latency_frames)
 {
-  if (params.format != CUBEB_SAMPLE_FLOAT32NE && params.format != CUBEB_SAMPLE_S16NE) {
+  if (params.format != CUBEB_SAMPLE_FLOAT32NE &&
+      params.format != CUBEB_SAMPLE_S16NE) {
     return CUBEB_ERROR_INVALID_FORMAT;
   }
 
@@ -1736,9 +1744,8 @@ wasapi_get_min_latency(cubeb * ctx, cubeb_stream_params params, uint32_t * laten
   }
 
   com_ptr<IAudioClient> client;
-  hr = device->Activate(__uuidof(IAudioClient),
-                        CLSCTX_INPROC_SERVER,
-                        NULL, client.receive_vpp());
+  hr = device->Activate(__uuidof(IAudioClient), CLSCTX_INPROC_SERVER, NULL,
+                        client.receive_vpp());
   if (FAILED(hr)) {
     LOG("Could not activate device for latency: %lx", hr);
     return CUBEB_ERROR;
@@ -1752,19 +1759,21 @@ wasapi_get_min_latency(cubeb * ctx, cubeb_stream_params params, uint32_t * laten
     return CUBEB_ERROR;
   }
 
-  LOG("default device period: %I64d, minimum device period: %I64d", default_period, minimum_period);
+  LOG("default device period: %I64d, minimum device period: %I64d",
+      default_period, minimum_period);
 
   /* If we're on Windows 10, we can use IAudioClient3 to get minimal latency.
      Otherwise, according to the docs, the best latency we can achieve is by
      synchronizing the stream and the engine.
-     http://msdn.microsoft.com/en-us/library/windows/desktop/dd370871%28v=vs.85%29.aspx */
+     http://msdn.microsoft.com/en-us/library/windows/desktop/dd370871%28v=vs.85%29.aspx
+   */
 
-   // #ifdef _WIN32_WINNT_WIN10
-  #if 0
+  // #ifdef _WIN32_WINNT_WIN10
+#if 0
      *latency_frames = hns_to_frames(params.rate, minimum_period);
-   #else
-    *latency_frames = hns_to_frames(params.rate, default_period);
-   #endif
+#else
+  *latency_frames = hns_to_frames(params.rate, default_period);
+#endif
 
   LOG("Minimum latency in frames: %u", *latency_frames);
 
@@ -1781,9 +1790,8 @@ wasapi_get_preferred_sample_rate(cubeb * ctx, uint32_t * rate)
   }
 
   com_ptr<IAudioClient> client;
-  hr = device->Activate(__uuidof(IAudioClient),
-                        CLSCTX_INPROC_SERVER,
-                        NULL, client.receive_vpp());
+  hr = device->Activate(__uuidof(IAudioClient), CLSCTX_INPROC_SERVER, NULL,
+                        client.receive_vpp());
   if (FAILED(hr)) {
     return CUBEB_ERROR;
   }
@@ -1802,7 +1810,8 @@ wasapi_get_preferred_sample_rate(cubeb * ctx, uint32_t * rate)
   return CUBEB_OK;
 }
 
-void wasapi_stream_destroy(cubeb_stream * stm);
+void
+wasapi_stream_destroy(cubeb_stream * stm);
 
 static void
 waveformatex_update_derived_properties(WAVEFORMATEX * format)
@@ -1810,7 +1819,8 @@ waveformatex_update_derived_properties(WAVEFORMATEX * format)
   format->nBlockAlign = format->wBitsPerSample * format->nChannels / 8;
   format->nAvgBytesPerSec = format->nSamplesPerSec * format->nBlockAlign;
   if (format->wFormatTag == WAVE_FORMAT_EXTENSIBLE) {
-    WAVEFORMATEXTENSIBLE * format_pcm = reinterpret_cast<WAVEFORMATEXTENSIBLE *>(format);
+    WAVEFORMATEXTENSIBLE * format_pcm =
+        reinterpret_cast<WAVEFORMATEXTENSIBLE *>(format);
     format_pcm->Samples.wValidBitsPerSample = format->wBitsPerSample;
   }
 }
@@ -1818,22 +1828,28 @@ waveformatex_update_derived_properties(WAVEFORMATEX * format)
 /* Based on the mix format and the stream format, try to find a way to play
    what the user requested. */
 static void
-handle_channel_layout(cubeb_stream * stm,  EDataFlow direction, com_heap_ptr<WAVEFORMATEX> & mix_format, const cubeb_stream_params * stream_params)
+handle_channel_layout(cubeb_stream * stm, EDataFlow direction,
+                      com_heap_ptr<WAVEFORMATEX> & mix_format,
+                      const cubeb_stream_params * stream_params)
 {
-  com_ptr<IAudioClient> & audio_client = (direction == eRender) ? stm->output_client : stm->input_client;
+  com_ptr<IAudioClient> & audio_client =
+      (direction == eRender) ? stm->output_client : stm->input_client;
   XASSERT(audio_client);
   /* The docs say that GetMixFormat is always of type WAVEFORMATEXTENSIBLE [1],
      so the reinterpret_cast below should be safe. In practice, this is not
      true, and we just want to bail out and let the rest of the code find a good
      conversion path instead of trying to make WASAPI do it by itself.
-     [1]: http://msdn.microsoft.com/en-us/library/windows/desktop/dd370811%28v=vs.85%29.aspx*/
+     [1]:
+     http://msdn.microsoft.com/en-us/library/windows/desktop/dd370811%28v=vs.85%29.aspx*/
   if (mix_format->wFormatTag != WAVE_FORMAT_EXTENSIBLE) {
     return;
   }
 
-  WAVEFORMATEXTENSIBLE * format_pcm = reinterpret_cast<WAVEFORMATEXTENSIBLE *>(mix_format.get());
+  WAVEFORMATEXTENSIBLE * format_pcm =
+      reinterpret_cast<WAVEFORMATEXTENSIBLE *>(mix_format.get());
 
-  /* Stash a copy of the original mix format in case we need to restore it later. */
+  /* Stash a copy of the original mix format in case we need to restore it
+   * later. */
   WAVEFORMATEXTENSIBLE hw_mix_format = *format_pcm;
 
   /* Get the channel mask by the channel layout.
@@ -1845,8 +1861,7 @@ handle_channel_layout(cubeb_stream * stm,  EDataFlow direction, com_heap_ptr<WAV
   /* Check if wasapi will accept our channel layout request. */
   WAVEFORMATEX * tmp = nullptr;
   HRESULT hr = audio_client->IsFormatSupported(AUDCLNT_SHAREMODE_SHARED,
-                                               mix_format.get(),
-                                               &tmp);
+                                               mix_format.get(), &tmp);
   com_heap_ptr<WAVEFORMATEX> closest(tmp);
   if (hr == S_FALSE) {
     /* Channel layout not supported, but WASAPI gives us a suggestion. Use it,
@@ -1854,7 +1869,8 @@ handle_channel_layout(cubeb_stream * stm,  EDataFlow direction, com_heap_ptr<WAV
        the suggestion, since it seems to always be IEEE_FLOAT. */
     LOG("Using WASAPI suggested format: channels: %d", closest->nChannels);
     XASSERT(closest->wFormatTag == WAVE_FORMAT_EXTENSIBLE);
-    WAVEFORMATEXTENSIBLE * closest_pcm = reinterpret_cast<WAVEFORMATEXTENSIBLE *>(closest.get());
+    WAVEFORMATEXTENSIBLE * closest_pcm =
+        reinterpret_cast<WAVEFORMATEXTENSIBLE *>(closest.get());
     format_pcm->dwChannelMask = closest_pcm->dwChannelMask;
     mix_format->nChannels = closest->nChannels;
     waveformatex_update_derived_properties(mix_format.get());
@@ -1877,10 +1893,11 @@ initialize_iaudioclient2(com_ptr<IAudioClient> & audio_client)
   com_ptr<IAudioClient2> audio_client2;
   audio_client->QueryInterface<IAudioClient2>(audio_client2.receive());
   if (!audio_client2) {
-    LOG("Could not get IAudioClient2 interface, not setting AUDCLNT_STREAMOPTIONS_RAW.");
+    LOG("Could not get IAudioClient2 interface, not setting "
+        "AUDCLNT_STREAMOPTIONS_RAW.");
     return CUBEB_OK;
   }
-  AudioClientProperties properties = { 0 };
+  AudioClientProperties properties = {0};
   properties.cbSize = sizeof(AudioClientProperties);
 #ifndef __MINGW32__
   properties.Options |= AUDCLNT_STREAMOPTIONS_RAW;
@@ -1898,8 +1915,7 @@ initialize_iaudioclient2(com_ptr<IAudioClient> & audio_client)
 initialize_iaudioclient3(com_ptr<IAudioClient> & audio_client,
                          cubeb_stream * stm,
                          const com_heap_ptr<WAVEFORMATEX> & mix_format,
-                         DWORD flags,
-                         EDataFlow direction)
+                         DWORD flags, EDataFlow direction)
 {
   com_ptr<IAudioClient3> audio_client3;
   audio_client->QueryInterface<IAudioClient3>(audio_client3.receive());
@@ -1923,9 +1939,10 @@ initialize_iaudioclient3(com_ptr<IAudioClient> & audio_client,
   }
 
   // Possibly initialize a shared-mode stream using IAudioClient3. Initializing
-  // a stream this way lets you request lower latencies, but also locks the global
-  // WASAPI engine at that latency.
-  // - If we request a shared-mode stream, streams created with IAudioClient will
+  // a stream this way lets you request lower latencies, but also locks the
+  // global WASAPI engine at that latency.
+  // - If we request a shared-mode stream, streams created with IAudioClient
+  // will
   //   have their latency adjusted to match. When  the shared-mode stream is
   //   closed, they'll go back to normal.
   // - If there's already a shared-mode stream running, then we cannot request
@@ -1934,18 +1951,24 @@ initialize_iaudioclient3(com_ptr<IAudioClient> & audio_client,
   //   would do this, then stop and use IAudioClient instead.
 
   HRESULT hr;
-  uint32_t default_period = 0, fundamental_period = 0, min_period = 0, max_period = 0;
-  hr = audio_client3->GetSharedModeEnginePeriod(mix_format.get(), &default_period, &fundamental_period, &min_period, &max_period);
+  uint32_t default_period = 0, fundamental_period = 0, min_period = 0,
+           max_period = 0;
+  hr = audio_client3->GetSharedModeEnginePeriod(
+      mix_format.get(), &default_period, &fundamental_period, &min_period,
+      &max_period);
   if (FAILED(hr)) {
     LOG("Could not get shared mode engine period: error: %lx", hr);
     return false;
   }
   uint32_t requested_latency = stm->latency;
   if (requested_latency >= default_period) {
-    LOG("Requested latency %i greater than default latency %i, not using IAudioClient3", requested_latency, default_period);
+    LOG("Requested latency %i greater than default latency %i, not using "
+        "IAudioClient3",
+        requested_latency, default_period);
     return false;
   }
-  LOG("Got shared mode engine period: default=%i fundamental=%i min=%i max=%i", default_period, fundamental_period, min_period, max_period);
+  LOG("Got shared mode engine period: default=%i fundamental=%i min=%i max=%i",
+      default_period, fundamental_period, min_period, max_period);
   // Snap requested latency to a valid value
   uint32_t old_requested_latency = requested_latency;
   if (requested_latency < min_period) {
@@ -1953,25 +1976,28 @@ initialize_iaudioclient3(com_ptr<IAudioClient> & audio_client,
   }
   requested_latency -= (requested_latency - min_period) % fundamental_period;
   if (requested_latency != old_requested_latency) {
-    LOG("Requested latency %i was adjusted to %i", old_requested_latency, requested_latency);
+    LOG("Requested latency %i was adjusted to %i", old_requested_latency,
+        requested_latency);
   }
 
-  hr = audio_client3->InitializeSharedAudioStream(flags, requested_latency, mix_format.get(), NULL);
+  hr = audio_client3->InitializeSharedAudioStream(flags, requested_latency,
+                                                  mix_format.get(), NULL);
   if (SUCCEEDED(hr)) {
     return true;
-  }
-  else if (hr == AUDCLNT_E_ENGINE_PERIODICITY_LOCKED) {
+  } else if (hr == AUDCLNT_E_ENGINE_PERIODICITY_LOCKED) {
     LOG("Got AUDCLNT_E_ENGINE_PERIODICITY_LOCKED, adjusting latency request");
   } else {
-    LOG("Could not initialize shared stream with IAudioClient3: error: %lx", hr);
+    LOG("Could not initialize shared stream with IAudioClient3: error: %lx",
+        hr);
     return false;
   }
 
   uint32_t current_period = 0;
-  WAVEFORMATEX* current_format = nullptr;
+  WAVEFORMATEX * current_format = nullptr;
   // We have to pass a valid WAVEFORMATEX** and not nullptr, otherwise
   // GetCurrentSharedModeEnginePeriod will return E_POINTER
-  hr = audio_client3->GetCurrentSharedModeEnginePeriod(&current_format, &current_period);
+  hr = audio_client3->GetCurrentSharedModeEnginePeriod(&current_format,
+                                                       &current_period);
   CoTaskMemFree(current_format);
   if (FAILED(hr)) {
     LOG("Could not get current shared mode engine period: error: %lx", hr);
@@ -1979,13 +2005,16 @@ initialize_iaudioclient3(com_ptr<IAudioClient> & audio_client,
   }
 
   if (current_period >= default_period) {
-    LOG("Current shared mode engine period %i too high, not using IAudioClient", current_period);
+    LOG("Current shared mode engine period %i too high, not using IAudioClient",
+        current_period);
     return false;
   }
 
-  hr = audio_client3->InitializeSharedAudioStream(flags, current_period, mix_format.get(), NULL);
+  hr = audio_client3->InitializeSharedAudioStream(flags, current_period,
+                                                  mix_format.get(), NULL);
   if (SUCCEEDED(hr)) {
-    LOG("Current shared mode engine period is %i instead of requested %i", current_period, requested_latency);
+    LOG("Current shared mode engine period is %i instead of requested %i",
+        current_period, requested_latency);
     return true;
   }
 
@@ -1995,18 +2024,16 @@ initialize_iaudioclient3(com_ptr<IAudioClient> & audio_client,
 
 #define DIRECTION_NAME (direction == eCapture ? "capture" : "render")
 
-template<typename T>
-int setup_wasapi_stream_one_side(cubeb_stream * stm,
-                                 cubeb_stream_params * stream_params,
-                                 wchar_t const * devid,
-                                 EDataFlow direction,
-                                 REFIID riid,
-                                 com_ptr<IAudioClient> & audio_client,
-                                 uint32_t * buffer_frame_count,
-                                 HANDLE & event,
-                                 T & render_or_capture_client,
-                                 cubeb_stream_params * mix_params,
-                                 com_ptr<IMMDevice>& device)
+template <typename T>
+int
+setup_wasapi_stream_one_side(cubeb_stream * stm,
+                             cubeb_stream_params * stream_params,
+                             wchar_t const * devid, EDataFlow direction,
+                             REFIID riid, com_ptr<IAudioClient> & audio_client,
+                             uint32_t * buffer_frame_count, HANDLE & event,
+                             T & render_or_capture_client,
+                             cubeb_stream_params * mix_params,
+                             com_ptr<IMMDevice> & device)
 {
   HRESULT hr;
   bool is_loopback = stream_params->prefs & CUBEB_STREAM_PREF_LOOPBACK;
@@ -2030,12 +2057,16 @@ int setup_wasapi_stream_one_side(cubeb_stream * stm,
       // If caller has requested loopback but not specified a device, look for
       // the default render device. Otherwise look for the default device
       // appropriate to the direction.
-      hr = get_default_endpoint(device, is_loopback ? eRender : direction, pref_to_role(stream_params->prefs));
+      hr = get_default_endpoint(device, is_loopback ? eRender : direction,
+                                pref_to_role(stream_params->prefs));
       if (FAILED(hr)) {
         if (is_loopback) {
-          LOG("Could not get default render endpoint for loopback, error: %lx\n", hr);
+          LOG("Could not get default render endpoint for loopback, error: "
+              "%lx\n",
+              hr);
         } else {
-          LOG("Could not get default %s endpoint, error: %lx\n", DIRECTION_NAME, hr);
+          LOG("Could not get default %s endpoint, error: %lx\n", DIRECTION_NAME,
+              hr);
         }
         return CUBEB_ERROR;
       }
@@ -2049,16 +2080,16 @@ int setup_wasapi_stream_one_side(cubeb_stream * stm,
                           NULL, audio_client.receive_vpp());
     if (hr == E_NOINTERFACE) {
 #endif
-      hr = device->Activate(__uuidof(IAudioClient),
-                            CLSCTX_INPROC_SERVER,
-                            NULL, audio_client.receive_vpp());
+    hr = device->Activate(__uuidof(IAudioClient), CLSCTX_INPROC_SERVER, NULL,
+                          audio_client.receive_vpp());
 #if 0
     }
 #endif
 
     if (FAILED(hr)) {
       LOG("Could not activate the device to get an audio"
-          " client for %s: error: %lx\n", DIRECTION_NAME, hr);
+          " client for %s: error: %lx\n",
+          DIRECTION_NAME, hr);
       // A particular device can't be activated because it has been
       // unplugged, try fall back to the default audio device.
       if (devid && hr == AUDCLNT_E_DEVICE_INVALIDATED) {
@@ -2080,7 +2111,8 @@ int setup_wasapi_stream_one_side(cubeb_stream * stm,
   hr = audio_client->GetMixFormat(&tmp);
   if (FAILED(hr)) {
     LOG("Could not fetch current mix format from the audio"
-        " client for %s: error: %lx", DIRECTION_NAME, hr);
+        " client for %s: error: %lx",
+        DIRECTION_NAME, hr);
     return CUBEB_ERROR;
   }
   com_heap_ptr<WAVEFORMATEX> mix_format(tmp);
@@ -2104,7 +2136,8 @@ int setup_wasapi_stream_one_side(cubeb_stream * stm,
   }
 
   if (mix_format->wFormatTag == WAVE_FORMAT_EXTENSIBLE) {
-    WAVEFORMATEXTENSIBLE * format_pcm = reinterpret_cast<WAVEFORMATEXTENSIBLE *>(mix_format.get());
+    WAVEFORMATEXTENSIBLE * format_pcm =
+        reinterpret_cast<WAVEFORMATEXTENSIBLE *>(mix_format.get());
     format_pcm->SubFormat = stm->waveformatextensible_sub_format;
   }
   waveformatex_update_derived_properties(mix_format.get());
@@ -2123,10 +2156,8 @@ int setup_wasapi_stream_one_side(cubeb_stream * stm,
 
   LOG("Setup requested=[f=%d r=%u c=%u l=%u] mix=[f=%d r=%u c=%u l=%u]",
       stream_params->format, stream_params->rate, stream_params->channels,
-      stream_params->layout,
-      mix_params->format, mix_params->rate, mix_params->channels,
-      mix_params->layout);
-
+      stream_params->layout, mix_params->format, mix_params->rate,
+      mix_params->channels, mix_params->layout);
 
   DWORD flags = 0;
 
@@ -2151,12 +2182,14 @@ int setup_wasapi_stream_one_side(cubeb_stream * stm,
 
   uint32_t latency_frames = stm->latency;
   cubeb_device_info device_info;
-  int rv = wasapi_create_device(stm->context, device_info, stm->device_enumerator.get(), device.get());
+  int rv = wasapi_create_device(stm->context, device_info,
+                                stm->device_enumerator.get(), device.get());
   if (rv == CUBEB_OK) {
-    const char* HANDSFREE_TAG = "BTHHFENUM";
+    const char * HANDSFREE_TAG = "BTHHFENUM";
     size_t len = sizeof(HANDSFREE_TAG);
     if (direction == eCapture) {
-      uint32_t default_period_frames = hns_to_frames(device_info.default_rate, default_period);
+      uint32_t default_period_frames =
+          hns_to_frames(device_info.default_rate, default_period);
       if (strlen(device_info.group_id) >= len &&
           strncmp(device_info.group_id, HANDSFREE_TAG, len) == 0) {
         stm->input_bluetooth_handsfree = true;
@@ -2165,7 +2198,8 @@ int setup_wasapi_stream_one_side(cubeb_stream * stm,
       }
       // This multiplicator has been found empirically.
       latency_frames = default_period_frames * 8;
-      LOG("Input: latency increased to %u frames from a default of %u", latency_frames, default_period_frames);
+      LOG("Input: latency increased to %u frames from a default of %u",
+          latency_frames, default_period_frames);
     }
     latency_hns = frames_to_hns(device_info.default_rate, latency_frames);
 
@@ -2188,12 +2222,8 @@ int setup_wasapi_stream_one_side(cubeb_stream * stm,
     LOG("Initialized with IAudioClient3");
   } else {
 #endif
-    hr = audio_client->Initialize(AUDCLNT_SHAREMODE_SHARED,
-                                  flags,
-                                  latency_hns,
-                                  0,
-                                  mix_format.get(),
-                                  NULL);
+  hr = audio_client->Initialize(AUDCLNT_SHAREMODE_SHARED, flags, latency_hns, 0,
+                                mix_format.get(), NULL);
 #if 0
   }
 #endif
@@ -2205,7 +2235,8 @@ int setup_wasapi_stream_one_side(cubeb_stream * stm,
   hr = audio_client->GetBufferSize(buffer_frame_count);
   if (FAILED(hr)) {
     LOG("Could not get the buffer size from the client"
-        " for %s %lx.", DIRECTION_NAME, hr);
+        " for %s %lx.",
+        DIRECTION_NAME, hr);
     return CUBEB_ERROR;
   }
 
@@ -2215,8 +2246,8 @@ int setup_wasapi_stream_one_side(cubeb_stream * stm,
   if (!is_loopback) {
     hr = audio_client->SetEventHandle(event);
     if (FAILED(hr)) {
-      LOG("Could set the event handle for the %s client %lx.",
-          DIRECTION_NAME, hr);
+      LOG("Could set the event handle for the %s client %lx.", DIRECTION_NAME,
+          hr);
       return CUBEB_ERROR;
     }
   }
@@ -2232,7 +2263,9 @@ int setup_wasapi_stream_one_side(cubeb_stream * stm,
 
 #undef DIRECTION_NAME
 
-void wasapi_find_matching_output_device(cubeb_stream * stm) {
+void
+wasapi_find_matching_output_device(cubeb_stream * stm)
+{
   HRESULT hr;
   cubeb_device_info * input_device = nullptr;
   cubeb_device_collection collection;
@@ -2255,7 +2288,10 @@ void wasapi_find_matching_output_device(cubeb_stream * stm) {
     return;
   }
 
-  int rv = wasapi_enumerate_devices(stm->context, (cubeb_device_type)(CUBEB_DEVICE_TYPE_INPUT|CUBEB_DEVICE_TYPE_OUTPUT), &collection);
+  int rv = wasapi_enumerate_devices(
+      stm->context,
+      (cubeb_device_type)(CUBEB_DEVICE_TYPE_INPUT | CUBEB_DEVICE_TYPE_OUTPUT),
+      &collection);
   if (rv != CUBEB_OK) {
     return;
   }
@@ -2284,37 +2320,34 @@ void wasapi_find_matching_output_device(cubeb_stream * stm) {
   wasapi_device_collection_destroy(stm->context, &collection);
 }
 
-int setup_wasapi_stream(cubeb_stream * stm)
+int
+setup_wasapi_stream(cubeb_stream * stm)
 {
   int rv;
 
   stm->stream_reset_lock.assert_current_thread_owns();
 
-  XASSERT((!stm->output_client || !stm->input_client) && "WASAPI stream already setup, close it first.");
+  XASSERT((!stm->output_client || !stm->input_client) &&
+          "WASAPI stream already setup, close it first.");
 
   if (has_input(stm)) {
     LOG("(%p) Setup capture: device=%p", stm, stm->input_device_id.get());
-    rv = setup_wasapi_stream_one_side(stm,
-                                      &stm->input_stream_params,
-                                      stm->input_device_id.get(),
-                                      eCapture,
-                                      __uuidof(IAudioCaptureClient),
-                                      stm->input_client,
-                                      &stm->input_buffer_frame_count,
-                                      stm->input_available_event,
-                                      stm->capture_client,
-                                      &stm->input_mix_params,
-                                      stm->input_device);
+    rv = setup_wasapi_stream_one_side(
+        stm, &stm->input_stream_params, stm->input_device_id.get(), eCapture,
+        __uuidof(IAudioCaptureClient), stm->input_client,
+        &stm->input_buffer_frame_count, stm->input_available_event,
+        stm->capture_client, &stm->input_mix_params, stm->input_device);
     if (rv != CUBEB_OK) {
       LOG("Failure to open the input side.");
       return rv;
     }
 
-    // We initializing an input stream, buffer ahead two buffers worth of silence.
-    // This delays the input side slightly, but allow to not glitch when no input
-    // is available when calling into the resampler to call the callback: the input
-    // refill event will be set shortly after to compensate for this lack of data.
-    // In debug, four buffers are used, to avoid tripping up assertions down the line.
+    // We initializing an input stream, buffer ahead two buffers worth of
+    // silence. This delays the input side slightly, but allow to not glitch
+    // when no input is available when calling into the resampler to call the
+    // callback: the input refill event will be set shortly after to compensate
+    // for this lack of data. In debug, four buffers are used, to avoid tripping
+    // up assertions down the line.
 #if !defined(DEBUG)
     const int silent_buffer_count = 2;
 #else
@@ -2337,7 +2370,8 @@ int setup_wasapi_stream(cubeb_stream * stm)
   // we attempt to open that same device in output mode in order to drive the
   // loopback via the output events.
   stm->has_dummy_output = false;
-  if (!has_output(stm) && stm->input_stream_params.prefs & CUBEB_STREAM_PREF_LOOPBACK) {
+  if (!has_output(stm) &&
+      stm->input_stream_params.prefs & CUBEB_STREAM_PREF_LOOPBACK) {
     stm->output_stream_params.rate = stm->input_stream_params.rate;
     stm->output_stream_params.channels = stm->input_stream_params.channels;
     stm->output_stream_params.layout = stm->input_stream_params.layout;
@@ -2356,17 +2390,11 @@ int setup_wasapi_stream(cubeb_stream * stm)
 
   if (has_output(stm)) {
     LOG("(%p) Setup render: device=%p", stm, stm->output_device_id.get());
-    rv = setup_wasapi_stream_one_side(stm,
-                                      &stm->output_stream_params,
-                                      stm->output_device_id.get(),
-                                      eRender,
-                                      __uuidof(IAudioRenderClient),
-                                      stm->output_client,
-                                      &stm->output_buffer_frame_count,
-                                      stm->refill_event,
-                                      stm->render_client,
-                                      &stm->output_mix_params,
-                                      stm->output_device);
+    rv = setup_wasapi_stream_one_side(
+        stm, &stm->output_stream_params, stm->output_device_id.get(), eRender,
+        __uuidof(IAudioRenderClient), stm->output_client,
+        &stm->output_buffer_frame_count, stm->refill_event, stm->render_client,
+        &stm->output_mix_params, stm->output_device);
     if (rv != CUBEB_OK) {
       LOG("Failure to open the output side.");
       return rv;
@@ -2423,14 +2451,12 @@ int setup_wasapi_stream(cubeb_stream * stm)
   cubeb_stream_params output_params = stm->output_mix_params;
   output_params.channels = stm->output_stream_params.channels;
 
-  stm->resampler.reset(
-    cubeb_resampler_create(stm,
-                           has_input(stm) ? &input_params : nullptr,
-                           has_output(stm) ? &output_params : nullptr,
-                           target_sample_rate,
-                           stm->data_callback,
-                           stm->user_ptr,
-                           stm->voice ? CUBEB_RESAMPLER_QUALITY_VOIP : CUBEB_RESAMPLER_QUALITY_DESKTOP));
+  stm->resampler.reset(cubeb_resampler_create(
+      stm, has_input(stm) ? &input_params : nullptr,
+      has_output(stm) ? &output_params : nullptr, target_sample_rate,
+      stm->data_callback, stm->user_ptr,
+      stm->voice ? CUBEB_RESAMPLER_QUALITY_VOIP
+                 : CUBEB_RESAMPLER_QUALITY_DESKTOP));
   if (!stm->resampler) {
     LOG("Could not get a resampler");
     return CUBEB_ERROR;
@@ -2455,28 +2481,28 @@ int setup_wasapi_stream(cubeb_stream * stm)
       LOG("Input stream using undefined layout! Any mixing may be "
           "unpredictable!\n");
     }
-    stm->input_mixer.reset(cubeb_mixer_create(stm->input_stream_params.format,
-                                              stm->input_mix_params.channels,
-                                              stm->input_mix_params.layout,
-                                              stm->input_stream_params.channels,
-                                              stm->input_stream_params.layout));
+    stm->input_mixer.reset(cubeb_mixer_create(
+        stm->input_stream_params.format, stm->input_mix_params.channels,
+        stm->input_mix_params.layout, stm->input_stream_params.channels,
+        stm->input_stream_params.layout));
     assert(stm->input_mixer);
   }
 
   // Create output mixer.
-  if (has_output(stm) && stm->output_mix_params.layout != stm->output_stream_params.layout) {
+  if (has_output(stm) &&
+      stm->output_mix_params.layout != stm->output_stream_params.layout) {
     if (stm->output_mix_params.layout == CUBEB_LAYOUT_UNDEFINED) {
-      LOG("Output stream using undefined layout! Any mixing may be unpredictable!\n");
+      LOG("Output stream using undefined layout! Any mixing may be "
+          "unpredictable!\n");
     }
-    stm->output_mixer.reset(cubeb_mixer_create(stm->output_stream_params.format,
-                                               stm->output_stream_params.channels,
-                                               stm->output_stream_params.layout,
-                                               stm->output_mix_params.channels,
-                                               stm->output_mix_params.layout));
+    stm->output_mixer.reset(cubeb_mixer_create(
+        stm->output_stream_params.format, stm->output_stream_params.channels,
+        stm->output_stream_params.layout, stm->output_mix_params.channels,
+        stm->output_mix_params.layout));
     assert(stm->output_mixer);
     // Input is up/down mixed when depacketized in get_input_buffer.
     stm->mix_buffer.resize(
-      frames_to_bytes_before_mix(stm, stm->output_buffer_frame_count));
+        frames_to_bytes_before_mix(stm, stm->output_buffer_frame_count));
   }
 
   return CUBEB_OK;
@@ -2494,12 +2520,12 @@ pref_to_role(cubeb_stream_prefs prefs)
 
 int
 wasapi_stream_init(cubeb * context, cubeb_stream ** stream,
-                   char const * stream_name,
-                   cubeb_devid input_device,
+                   char const * stream_name, cubeb_devid input_device,
                    cubeb_stream_params * input_stream_params,
                    cubeb_devid output_device,
                    cubeb_stream_params * output_stream_params,
-                   unsigned int latency_frames, cubeb_data_callback data_callback,
+                   unsigned int latency_frames,
+                   cubeb_data_callback data_callback,
                    cubeb_state_callback state_callback, void * user_ptr)
 {
   int rv;
@@ -2511,7 +2537,8 @@ wasapi_stream_init(cubeb * context, cubeb_stream ** stream,
     return CUBEB_ERROR_INVALID_FORMAT;
   }
 
-  std::unique_ptr<cubeb_stream, decltype(&wasapi_stream_destroy)> stm(new cubeb_stream(), wasapi_stream_destroy);
+  std::unique_ptr<cubeb_stream, decltype(&wasapi_stream_destroy)> stm(
+      new cubeb_stream(), wasapi_stream_destroy);
 
   stm->context = context;
   stm->data_callback = data_callback;
@@ -2520,9 +2547,9 @@ wasapi_stream_init(cubeb * context, cubeb_stream ** stream,
   stm->role = eConsole;
   stm->input_bluetooth_handsfree = false;
 
-  HRESULT hr = CoCreateInstance(__uuidof(MMDeviceEnumerator),
-                                NULL, CLSCTX_INPROC_SERVER,
-                                IID_PPV_ARGS(stm->device_enumerator.receive()));
+  HRESULT hr =
+      CoCreateInstance(__uuidof(MMDeviceEnumerator), NULL, CLSCTX_INPROC_SERVER,
+                       IID_PPV_ARGS(stm->device_enumerator.receive()));
   if (FAILED(hr)) {
     LOG("Could not get device enumerator: %lx", hr);
     return hr;
@@ -2530,11 +2557,13 @@ wasapi_stream_init(cubeb * context, cubeb_stream ** stream,
 
   if (input_stream_params) {
     stm->input_stream_params = *input_stream_params;
-    stm->input_device_id = utf8_to_wstr(reinterpret_cast<char const *>(input_device));
+    stm->input_device_id =
+        utf8_to_wstr(reinterpret_cast<char const *>(input_device));
   }
   if (output_stream_params) {
     stm->output_stream_params = *output_stream_params;
-    stm->output_device_id = utf8_to_wstr(reinterpret_cast<char const *>(output_device));
+    stm->output_device_id =
+        utf8_to_wstr(reinterpret_cast<char const *>(output_device));
   }
 
   if (stm->output_stream_params.prefs & CUBEB_STREAM_PREF_VOICE ||
@@ -2544,19 +2573,20 @@ wasapi_stream_init(cubeb * context, cubeb_stream ** stream,
     stm->voice = false;
   }
 
-  switch (output_stream_params ? output_stream_params->format : input_stream_params->format) {
-    case CUBEB_SAMPLE_S16NE:
-      stm->bytes_per_sample = sizeof(short);
-      stm->waveformatextensible_sub_format = KSDATAFORMAT_SUBTYPE_PCM;
-      stm->linear_input_buffer.reset(new auto_array_wrapper_impl<short>);
-      break;
-    case CUBEB_SAMPLE_FLOAT32NE:
-      stm->bytes_per_sample = sizeof(float);
-      stm->waveformatextensible_sub_format = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
-      stm->linear_input_buffer.reset(new auto_array_wrapper_impl<float>);
-      break;
-    default:
-      return CUBEB_ERROR_INVALID_FORMAT;
+  switch (output_stream_params ? output_stream_params->format
+                               : input_stream_params->format) {
+  case CUBEB_SAMPLE_S16NE:
+    stm->bytes_per_sample = sizeof(short);
+    stm->waveformatextensible_sub_format = KSDATAFORMAT_SUBTYPE_PCM;
+    stm->linear_input_buffer.reset(new auto_array_wrapper_impl<short>);
+    break;
+  case CUBEB_SAMPLE_FLOAT32NE:
+    stm->bytes_per_sample = sizeof(float);
+    stm->waveformatextensible_sub_format = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
+    stm->linear_input_buffer.reset(new auto_array_wrapper_impl<float>);
+    break;
+  default:
+    return CUBEB_ERROR_INVALID_FORMAT;
   }
 
   stm->latency = latency_frames;
@@ -2591,10 +2621,12 @@ wasapi_stream_init(cubeb * context, cubeb_stream ** stream,
     return rv;
   }
 
-  if (!((input_stream_params ?
-         (input_stream_params->prefs & CUBEB_STREAM_PREF_DISABLE_DEVICE_SWITCHING) : 0) ||
-        (output_stream_params ?
-         (output_stream_params->prefs & CUBEB_STREAM_PREF_DISABLE_DEVICE_SWITCHING) : 0))) {
+  if (!((input_stream_params ? (input_stream_params->prefs &
+                                CUBEB_STREAM_PREF_DISABLE_DEVICE_SWITCHING)
+                             : 0) ||
+        (output_stream_params ? (output_stream_params->prefs &
+                                 CUBEB_STREAM_PREF_DISABLE_DEVICE_SWITCHING)
+                              : 0))) {
     HRESULT hr = register_notification_client(stm.get());
     if (FAILED(hr)) {
       /* this is not fatal, we can still play audio, but we won't be able
@@ -2609,7 +2641,8 @@ wasapi_stream_init(cubeb * context, cubeb_stream ** stream,
   return CUBEB_OK;
 }
 
-void close_wasapi_stream(cubeb_stream * stm)
+void
+close_wasapi_stream(cubeb_stream * stm)
 {
   XASSERT(stm);
 
@@ -2629,7 +2662,10 @@ void close_wasapi_stream(cubeb_stream * stm)
 #endif
 
   stm->audio_clock = nullptr;
-  stm->total_frames_written += static_cast<UINT64>(round(stm->frames_written * stream_to_mix_samplerate_ratio(stm->output_stream_params, stm->output_mix_params)));
+  stm->total_frames_written += static_cast<UINT64>(
+      round(stm->frames_written *
+            stream_to_mix_samplerate_ratio(stm->output_stream_params,
+                                           stm->output_mix_params)));
   stm->frames_written = 0;
 
   stm->resampler.reset();
@@ -2641,7 +2677,8 @@ void close_wasapi_stream(cubeb_stream * stm)
   }
 }
 
-void wasapi_stream_destroy(cubeb_stream * stm)
+void
+wasapi_stream_destroy(cubeb_stream * stm)
 {
   XASSERT(stm);
   LOG("Stream destroy (%p)", stm);
@@ -2676,17 +2713,16 @@ void wasapi_stream_destroy(cubeb_stream * stm)
   delete stm;
 }
 
-enum StreamDirection {
-  OUTPUT,
-  INPUT
-};
+enum StreamDirection { OUTPUT, INPUT };
 
-int stream_start_one_side(cubeb_stream * stm, StreamDirection dir)
+int
+stream_start_one_side(cubeb_stream * stm, StreamDirection dir)
 {
   XASSERT((dir == OUTPUT && stm->output_client) ||
           (dir == INPUT && stm->input_client));
 
-  HRESULT hr = dir == OUTPUT ? stm->output_client->Start() : stm->input_client->Start();
+  HRESULT hr =
+      dir == OUTPUT ? stm->output_client->Start() : stm->input_client->Start();
   if (hr == AUDCLNT_E_DEVICE_INVALIDATED) {
     LOG("audioclient invalidated for %s device, reconfiguring",
         dir == OUTPUT ? "output" : "input");
@@ -2704,7 +2740,8 @@ int stream_start_one_side(cubeb_stream * stm, StreamDirection dir)
       return r;
     }
 
-    HRESULT hr2 = dir == OUTPUT ? stm->output_client->Start() : stm->input_client->Start();
+    HRESULT hr2 = dir == OUTPUT ? stm->output_client->Start()
+                                : stm->input_client->Start();
     if (FAILED(hr2)) {
       LOG("could not start the %s stream after reconfig: %lx",
           dir == OUTPUT ? "output" : "input", hr);
@@ -2719,7 +2756,8 @@ int stream_start_one_side(cubeb_stream * stm, StreamDirection dir)
   return CUBEB_OK;
 }
 
-int wasapi_stream_start(cubeb_stream * stm)
+int
+wasapi_stream_start(cubeb_stream * stm)
 {
   auto_lock lock(stm->stream_reset_lock);
 
@@ -2755,7 +2793,9 @@ int wasapi_stream_start(cubeb_stream * stm)
   }
 
   cubeb_async_log_reset_threads();
-  stm->thread = (HANDLE) _beginthreadex(NULL, 512 * 1024, wasapi_stream_render_loop, stm, STACK_SIZE_PARAM_IS_A_RESERVATION, NULL);
+  stm->thread =
+      (HANDLE)_beginthreadex(NULL, 512 * 1024, wasapi_stream_render_loop, stm,
+                             STACK_SIZE_PARAM_IS_A_RESERVATION, NULL);
   if (stm->thread == NULL) {
     LOG("could not create WASAPI render thread.");
     return CUBEB_ERROR;
@@ -2774,7 +2814,8 @@ int wasapi_stream_start(cubeb_stream * stm)
   return CUBEB_OK;
 }
 
-int wasapi_stream_stop(cubeb_stream * stm)
+int
+wasapi_stream_stop(cubeb_stream * stm)
 {
   XASSERT(stm);
   HRESULT hr;
@@ -2813,7 +2854,8 @@ int wasapi_stream_stop(cubeb_stream * stm)
   return CUBEB_OK;
 }
 
-int wasapi_stream_get_position(cubeb_stream * stm, uint64_t * position)
+int
+wasapi_stream_get_position(cubeb_stream * stm, uint64_t * position)
 {
   XASSERT(stm && position);
   auto_lock lock(stm->stream_reset_lock);
@@ -2823,11 +2865,16 @@ int wasapi_stream_get_position(cubeb_stream * stm, uint64_t * position)
   }
 
   /* Calculate how far behind the current stream head the playback cursor is. */
-  uint64_t stream_delay = static_cast<uint64_t>(current_stream_delay(stm) * stm->output_stream_params.rate);
+  uint64_t stream_delay = static_cast<uint64_t>(current_stream_delay(stm) *
+                                                stm->output_stream_params.rate);
 
   /* Calculate the logical stream head in frames at the stream sample rate. */
-  uint64_t max_pos = stm->total_frames_written +
-                     static_cast<uint64_t>(round(stm->frames_written * stream_to_mix_samplerate_ratio(stm->output_stream_params, stm->output_mix_params)));
+  uint64_t max_pos =
+      stm->total_frames_written +
+      static_cast<uint64_t>(
+          round(stm->frames_written *
+                stream_to_mix_samplerate_ratio(stm->output_stream_params,
+                                               stm->output_mix_params)));
 
   *position = max_pos;
   if (stream_delay <= *position) {
@@ -2842,7 +2889,8 @@ int wasapi_stream_get_position(cubeb_stream * stm, uint64_t * position)
   return CUBEB_OK;
 }
 
-int wasapi_stream_get_latency(cubeb_stream * stm, uint32_t * latency)
+int
+wasapi_stream_get_latency(cubeb_stream * stm, uint32_t * latency)
 {
   XASSERT(stm && latency);
 
@@ -2868,11 +2916,11 @@ int wasapi_stream_get_latency(cubeb_stream * stm, uint32_t * latency)
   // This happens on windows 10: no error, but always 0 for latency.
   if (latency_hns == 0) {
     LOG("GetStreamLatency returned 0, using workaround.");
-     double delay_s = current_stream_delay(stm);
-     // convert to sample-frames
-     *latency = delay_s * stm->output_stream_params.rate;
+    double delay_s = current_stream_delay(stm);
+    // convert to sample-frames
+    *latency = delay_s * stm->output_stream_params.rate;
   } else {
-     *latency = hns_to_frames(stm, latency_hns);
+    *latency = hns_to_frames(stm, latency_hns);
   }
 
   LOG("Output latency %u frames.", *latency);
@@ -2880,8 +2928,8 @@ int wasapi_stream_get_latency(cubeb_stream * stm, uint32_t * latency)
   return CUBEB_OK;
 }
 
-
-int wasapi_stream_get_input_latency(cubeb_stream * stm, uint32_t * latency)
+int
+wasapi_stream_get_input_latency(cubeb_stream * stm, uint32_t * latency)
 {
   XASSERT(stm && latency);
 
@@ -2902,7 +2950,8 @@ int wasapi_stream_get_input_latency(cubeb_stream * stm, uint32_t * latency)
   return CUBEB_OK;
 }
 
-int wasapi_stream_set_volume(cubeb_stream * stm, float volume)
+int
+wasapi_stream_set_volume(cubeb_stream * stm, float volume)
 {
   auto_lock lock(stm->stream_reset_lock);
 
@@ -2935,26 +2984,26 @@ wstr_to_utf8(LPCWSTR str)
 }
 
 static std::unique_ptr<wchar_t const []>
-utf8_to_wstr(char const * str)
-{
+utf8_to_wstr(char const * str) {
   int size = ::MultiByteToWideChar(CP_UTF8, 0, str, -1, nullptr, 0);
   if (size <= 0) {
     return nullptr;
   }
 
-  std::unique_ptr<wchar_t []> ret(new wchar_t[size]);
+  std::unique_ptr<wchar_t[]> ret(new wchar_t[size]);
   ::MultiByteToWideChar(CP_UTF8, 0, str, -1, ret.get(), size);
   return ret;
 }
 
-static com_ptr<IMMDevice>
-wasapi_get_device_node(IMMDeviceEnumerator * enumerator, IMMDevice * dev)
+static com_ptr<IMMDevice> wasapi_get_device_node(
+    IMMDeviceEnumerator * enumerator, IMMDevice * dev)
 {
   com_ptr<IMMDevice> ret;
   com_ptr<IDeviceTopology> devtopo;
   com_ptr<IConnector> connector;
 
-  if (SUCCEEDED(dev->Activate(__uuidof(IDeviceTopology), CLSCTX_ALL, NULL, devtopo.receive_vpp())) &&
+  if (SUCCEEDED(dev->Activate(__uuidof(IDeviceTopology), CLSCTX_ALL, NULL,
+                              devtopo.receive_vpp())) &&
       SUCCEEDED(devtopo->GetConnector(0, connector.receive()))) {
     wchar_t * tmp = nullptr;
     if (SUCCEEDED(connector->GetDeviceIdConnectedTo(&tmp))) {
@@ -2990,7 +3039,8 @@ wasapi_is_default_device(EDataFlow flow, ERole role, LPCWSTR device_id,
 /* `ret` must be deallocated with `wasapi_destroy_device`, iff the return value
  * of this function is `CUBEB_OK`. */
 int
-wasapi_create_device(cubeb * ctx, cubeb_device_info& ret, IMMDeviceEnumerator * enumerator, IMMDevice * dev)
+wasapi_create_device(cubeb * ctx, cubeb_device_info & ret,
+                     IMMDeviceEnumerator * enumerator, IMMDevice * dev)
 {
   com_ptr<IMMEndpoint> endpoint;
   com_ptr<IMMDevice> devnode;
@@ -3059,7 +3109,7 @@ wasapi_create_device(cubeb * ctx, cubeb_device_info& ret, IMMDeviceEnumerator *
   }
   if (!ret.friendly_name) {
     // This is not fatal, but a valid string is expected in all cases.
-    char* empty = new char[1];
+    char * empty = new char[1];
     empty[0] = '\0';
     ret.friendly_name = empty;
   }
@@ -3082,20 +3132,24 @@ wasapi_create_device(cubeb * ctx, cubeb_device_info& ret, IMMDeviceEnumerator *
 
   if (!ret.group_id) {
     // This is not fatal, but a valid string is expected in all cases.
-    char* empty = new char[1];
+    char * empty = new char[1];
     empty[0] = '\0';
     ret.group_id = empty;
   }
 
   ret.preferred = CUBEB_DEVICE_PREF_NONE;
   if (wasapi_is_default_device(flow, eConsole, device_id.get(), enumerator)) {
-    ret.preferred = (cubeb_device_pref)(ret.preferred | CUBEB_DEVICE_PREF_MULTIMEDIA);
+    ret.preferred =
+        (cubeb_device_pref)(ret.preferred | CUBEB_DEVICE_PREF_MULTIMEDIA);
   }
-  if (wasapi_is_default_device(flow, eCommunications, device_id.get(), enumerator)) {
-    ret.preferred = (cubeb_device_pref)(ret.preferred | CUBEB_DEVICE_PREF_VOICE);
+  if (wasapi_is_default_device(flow, eCommunications, device_id.get(),
+                               enumerator)) {
+    ret.preferred =
+        (cubeb_device_pref)(ret.preferred | CUBEB_DEVICE_PREF_VOICE);
   }
   if (wasapi_is_default_device(flow, eConsole, device_id.get(), enumerator)) {
-    ret.preferred = (cubeb_device_pref)(ret.preferred | CUBEB_DEVICE_PREF_NOTIFICATION);
+    ret.preferred =
+        (cubeb_device_pref)(ret.preferred | CUBEB_DEVICE_PREF_NOTIFICATION);
   }
 
   if (flow == eRender) {
@@ -3105,29 +3159,32 @@ wasapi_create_device(cubeb * ctx, cubeb_device_info& ret, IMMDeviceEnumerator *
   }
 
   switch (state) {
-    case DEVICE_STATE_ACTIVE:
-      ret.state = CUBEB_DEVICE_STATE_ENABLED;
-      break;
-    case DEVICE_STATE_UNPLUGGED:
-      ret.state = CUBEB_DEVICE_STATE_UNPLUGGED;
-      break;
-    default:
-      ret.state = CUBEB_DEVICE_STATE_DISABLED;
-      break;
+  case DEVICE_STATE_ACTIVE:
+    ret.state = CUBEB_DEVICE_STATE_ENABLED;
+    break;
+  case DEVICE_STATE_UNPLUGGED:
+    ret.state = CUBEB_DEVICE_STATE_UNPLUGGED;
+    break;
+  default:
+    ret.state = CUBEB_DEVICE_STATE_DISABLED;
+    break;
   };
 
-  ret.format = static_cast<cubeb_device_fmt>(CUBEB_DEVICE_FMT_F32NE | CUBEB_DEVICE_FMT_S16NE);
+  ret.format = static_cast<cubeb_device_fmt>(CUBEB_DEVICE_FMT_F32NE |
+                                             CUBEB_DEVICE_FMT_S16NE);
   ret.default_format = CUBEB_DEVICE_FMT_F32NE;
   prop_variant fmtvar;
   hr = propstore->GetValue(PKEY_AudioEngine_DeviceFormat, &fmtvar);
   if (SUCCEEDED(hr) && fmtvar.vt == VT_BLOB) {
     if (fmtvar.blob.cbSize == sizeof(PCMWAVEFORMAT)) {
-      const PCMWAVEFORMAT * pcm = reinterpret_cast<const PCMWAVEFORMAT *>(fmtvar.blob.pBlobData);
+      const PCMWAVEFORMAT * pcm =
+          reinterpret_cast<const PCMWAVEFORMAT *>(fmtvar.blob.pBlobData);
 
       ret.max_rate = ret.min_rate = ret.default_rate = pcm->wf.nSamplesPerSec;
       ret.max_channels = pcm->wf.nChannels;
     } else if (fmtvar.blob.cbSize >= sizeof(WAVEFORMATEX)) {
-      WAVEFORMATEX* wfx = reinterpret_cast<WAVEFORMATEX*>(fmtvar.blob.pBlobData);
+      WAVEFORMATEX * wfx =
+          reinterpret_cast<WAVEFORMATEX *>(fmtvar.blob.pBlobData);
 
       if (fmtvar.blob.cbSize >= sizeof(WAVEFORMATEX) + wfx->cbSize ||
           wfx->wFormatTag == WAVE_FORMAT_PCM) {
@@ -3137,7 +3194,8 @@ wasapi_create_device(cubeb * ctx, cubeb_device_info& ret, IMMDeviceEnumerator *
     }
   }
 
-  if (SUCCEEDED(dev->Activate(__uuidof(IAudioClient), CLSCTX_INPROC_SERVER, NULL, client.receive_vpp())) &&
+  if (SUCCEEDED(dev->Activate(__uuidof(IAudioClient), CLSCTX_INPROC_SERVER,
+                              NULL, client.receive_vpp())) &&
       SUCCEEDED(client->GetDevicePeriod(&def_period, &min_period))) {
     ret.latency_lo = hns_to_frames(ret.default_rate, min_period);
     ret.latency_hi = hns_to_frames(ret.default_rate, def_period);
@@ -3154,8 +3212,8 @@ wasapi_create_device(cubeb * ctx, cubeb_device_info& ret, IMMDeviceEnumerator *
 void
 wasapi_destroy_device(cubeb_device_info * device)
 {
-  delete [] device->friendly_name;
-  delete [] device->group_id;
+  delete[] device->friendly_name;
+  delete[] device->group_id;
 }
 
 static int
@@ -3168,19 +3226,25 @@ wasapi_enumerate_devices(cubeb * context, cubeb_device_type type,
   UINT cc, i;
   EDataFlow flow;
 
-  hr = CoCreateInstance(__uuidof(MMDeviceEnumerator), NULL,
-                        CLSCTX_INPROC_SERVER, IID_PPV_ARGS(enumerator.receive()));
+  hr =
+      CoCreateInstance(__uuidof(MMDeviceEnumerator), NULL, CLSCTX_INPROC_SERVER,
+                       IID_PPV_ARGS(enumerator.receive()));
   if (FAILED(hr)) {
     LOG("Could not get device enumerator: %lx", hr);
     return CUBEB_ERROR;
   }
 
-  if (type == CUBEB_DEVICE_TYPE_OUTPUT) flow = eRender;
-  else if (type == CUBEB_DEVICE_TYPE_INPUT) flow = eCapture;
-  else if (type & (CUBEB_DEVICE_TYPE_INPUT | CUBEB_DEVICE_TYPE_OUTPUT)) flow = eAll;
-  else return CUBEB_ERROR;
+  if (type == CUBEB_DEVICE_TYPE_OUTPUT)
+    flow = eRender;
+  else if (type == CUBEB_DEVICE_TYPE_INPUT)
+    flow = eCapture;
+  else if (type & (CUBEB_DEVICE_TYPE_INPUT | CUBEB_DEVICE_TYPE_OUTPUT))
+    flow = eAll;
+  else
+    return CUBEB_ERROR;
 
-  hr = enumerator->EnumAudioEndpoints(flow, DEVICE_STATEMASK_ALL, collection.receive());
+  hr = enumerator->EnumAudioEndpoints(flow, DEVICE_STATEMASK_ALL,
+                                      collection.receive());
   if (FAILED(hr)) {
     LOG("Could not enumerate audio endpoints: %lx", hr);
     return CUBEB_ERROR;
@@ -3201,11 +3265,11 @@ wasapi_enumerate_devices(cubeb * context, cubeb_device_type type,
     com_ptr<IMMDevice> dev;
     hr = collection->Item(i, dev.receive());
     if (FAILED(hr)) {
-      LOG("IMMDeviceCollection::Item(%u) failed: %lx", i-1, hr);
+      LOG("IMMDeviceCollection::Item(%u) failed: %lx", i - 1, hr);
       continue;
     }
-    if (wasapi_create_device(context, devices[out->count],
-                             enumerator.get(), dev.get()) == CUBEB_OK) {
+    if (wasapi_create_device(context, devices[out->count], enumerator.get(),
+                             dev.get()) == CUBEB_OK) {
       out->count += 1;
     }
   }
@@ -3215,24 +3279,25 @@ wasapi_enumerate_devices(cubeb * context, cubeb_device_type type,
 }
 
 static int
-wasapi_device_collection_destroy(cubeb * /*ctx*/, cubeb_device_collection * collection)
+wasapi_device_collection_destroy(cubeb * /*ctx*/,
+                                 cubeb_device_collection * collection)
 {
   XASSERT(collection);
 
   for (size_t n = 0; n < collection->count; n++) {
-    cubeb_device_info& dev = collection->device[n];
+    cubeb_device_info & dev = collection->device[n];
     wasapi_destroy_device(&dev);
   }
 
-  delete [] collection->device;
+  delete[] collection->device;
   return CUBEB_OK;
 }
 
 static int
-wasapi_register_device_collection_changed(cubeb * context,
-                                          cubeb_device_type devtype,
-                                          cubeb_device_collection_changed_callback collection_changed_callback,
-                                          void * user_ptr)
+wasapi_register_device_collection_changed(
+    cubeb * context, cubeb_device_type devtype,
+    cubeb_device_collection_changed_callback collection_changed_callback,
+    void * user_ptr)
 {
   if (devtype == CUBEB_DEVICE_TYPE_UNKNOWN) {
     return CUBEB_ERROR_INVALID_PARAMETER;
@@ -3302,26 +3367,27 @@ wasapi_register_device_collection_changed(cubeb * context,
 }
 
 cubeb_ops const wasapi_ops = {
-  /*.init =*/ wasapi_init,
-  /*.get_backend_id =*/ wasapi_get_backend_id,
-  /*.get_max_channel_count =*/ wasapi_get_max_channel_count,
-  /*.get_min_latency =*/ wasapi_get_min_latency,
-  /*.get_preferred_sample_rate =*/ wasapi_get_preferred_sample_rate,
-  /*.enumerate_devices =*/ wasapi_enumerate_devices,
-  /*.device_collection_destroy =*/ wasapi_device_collection_destroy,
-  /*.destroy =*/ wasapi_destroy,
-  /*.stream_init =*/ wasapi_stream_init,
-  /*.stream_destroy =*/ wasapi_stream_destroy,
-  /*.stream_start =*/ wasapi_stream_start,
-  /*.stream_stop =*/ wasapi_stream_stop,
-  /*.stream_get_position =*/ wasapi_stream_get_position,
-  /*.stream_get_latency =*/ wasapi_stream_get_latency,
-  /*.stream_get_input_latency =*/ wasapi_stream_get_input_latency,
-  /*.stream_set_volume =*/ wasapi_stream_set_volume,
-  /*.stream_set_name =*/ NULL,
-  /*.stream_get_current_device =*/ NULL,
-  /*.stream_device_destroy =*/ NULL,
-  /*.stream_register_device_changed_callback =*/ NULL,
-  /*.register_device_collection_changed =*/ wasapi_register_device_collection_changed,
+    /*.init =*/wasapi_init,
+    /*.get_backend_id =*/wasapi_get_backend_id,
+    /*.get_max_channel_count =*/wasapi_get_max_channel_count,
+    /*.get_min_latency =*/wasapi_get_min_latency,
+    /*.get_preferred_sample_rate =*/wasapi_get_preferred_sample_rate,
+    /*.enumerate_devices =*/wasapi_enumerate_devices,
+    /*.device_collection_destroy =*/wasapi_device_collection_destroy,
+    /*.destroy =*/wasapi_destroy,
+    /*.stream_init =*/wasapi_stream_init,
+    /*.stream_destroy =*/wasapi_stream_destroy,
+    /*.stream_start =*/wasapi_stream_start,
+    /*.stream_stop =*/wasapi_stream_stop,
+    /*.stream_get_position =*/wasapi_stream_get_position,
+    /*.stream_get_latency =*/wasapi_stream_get_latency,
+    /*.stream_get_input_latency =*/wasapi_stream_get_input_latency,
+    /*.stream_set_volume =*/wasapi_stream_set_volume,
+    /*.stream_set_name =*/NULL,
+    /*.stream_get_current_device =*/NULL,
+    /*.stream_device_destroy =*/NULL,
+    /*.stream_register_device_changed_callback =*/NULL,
+    /*.register_device_collection_changed =*/
+    wasapi_register_device_collection_changed,
 };
-} // namespace anonymous
+} // namespace
diff --git a/src/cubeb_winmm.c b/src/cubeb_winmm.c
index 6498196..8cb307a 100644
--- a/src/cubeb_winmm.c
+++ b/src/cubeb_winmm.c
@@ -8,70 +8,77 @@
 #define WINVER 0x0501
 #undef WIN32_LEAN_AND_MEAN
 
+#include "cubeb-internal.h"
+#include "cubeb/cubeb.h"
 #include <malloc.h>
-#include <windows.h>
+#include <math.h>
 #include <mmreg.h>
 #include <mmsystem.h>
 #include <process.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <math.h>
-#include "cubeb/cubeb.h"
-#include "cubeb-internal.h"
+#include <windows.h>
 
 /* This is missing from the MinGW headers. Use a safe fallback. */
 #if !defined(MEMORY_ALLOCATION_ALIGNMENT)
 #define MEMORY_ALLOCATION_ALIGNMENT 16
 #endif
 
-/**This is also missing from the MinGW headers. It  also appears to be undocumented by Microsoft.*/
+/**This is also missing from the MinGW headers. It  also appears to be
+ * undocumented by Microsoft.*/
 #ifndef WAVE_FORMAT_48M08
-#define WAVE_FORMAT_48M08      0x00001000       /* 48     kHz, Mono, 8-bit */
+#define WAVE_FORMAT_48M08 0x00001000 /* 48     kHz, Mono, 8-bit */
 #endif
 #ifndef WAVE_FORMAT_48M16
-#define WAVE_FORMAT_48M16      0x00002000       /* 48     kHz, Mono, 16-bit */
+#define WAVE_FORMAT_48M16 0x00002000 /* 48     kHz, Mono, 16-bit */
 #endif
 #ifndef WAVE_FORMAT_48S08
-#define WAVE_FORMAT_48S08      0x00004000       /* 48     kHz, Stereo, 8-bit */
+#define WAVE_FORMAT_48S08 0x00004000 /* 48     kHz, Stereo, 8-bit */
 #endif
 #ifndef WAVE_FORMAT_48S16
-#define WAVE_FORMAT_48S16      0x00008000       /* 48     kHz, Stereo, 16-bit */
+#define WAVE_FORMAT_48S16 0x00008000 /* 48     kHz, Stereo, 16-bit */
 #endif
 #ifndef WAVE_FORMAT_96M08
-#define WAVE_FORMAT_96M08      0x00010000       /* 96     kHz, Mono, 8-bit */
+#define WAVE_FORMAT_96M08 0x00010000 /* 96     kHz, Mono, 8-bit */
 #endif
 #ifndef WAVE_FORMAT_96M16
-#define WAVE_FORMAT_96M16      0x00020000       /* 96     kHz, Mono, 16-bit */
+#define WAVE_FORMAT_96M16 0x00020000 /* 96     kHz, Mono, 16-bit */
 #endif
 #ifndef WAVE_FORMAT_96S08
-#define WAVE_FORMAT_96S08      0x00040000       /* 96     kHz, Stereo, 8-bit */
+#define WAVE_FORMAT_96S08 0x00040000 /* 96     kHz, Stereo, 8-bit */
 #endif
 #ifndef WAVE_FORMAT_96S16
-#define WAVE_FORMAT_96S16      0x00080000       /* 96     kHz, Stereo, 16-bit */
+#define WAVE_FORMAT_96S16 0x00080000 /* 96     kHz, Stereo, 16-bit */
 #endif
 
 /**Taken from winbase.h, also not in MinGW.*/
 #ifndef STACK_SIZE_PARAM_IS_A_RESERVATION
-#define STACK_SIZE_PARAM_IS_A_RESERVATION   0x00010000    // Threads only
+#define STACK_SIZE_PARAM_IS_A_RESERVATION 0x00010000 // Threads only
 #endif
 
 #ifndef DRVM_MAPPER
-#define DRVM_MAPPER             (0x2000)
+#define DRVM_MAPPER (0x2000)
 #endif
 #ifndef DRVM_MAPPER_PREFERRED_GET
-#define DRVM_MAPPER_PREFERRED_GET                 (DRVM_MAPPER+21)
+#define DRVM_MAPPER_PREFERRED_GET (DRVM_MAPPER + 21)
 #endif
 #ifndef DRVM_MAPPER_CONSOLEVOICECOM_GET
-#define DRVM_MAPPER_CONSOLEVOICECOM_GET           (DRVM_MAPPER+23)
+#define DRVM_MAPPER_CONSOLEVOICECOM_GET (DRVM_MAPPER + 23)
 #endif
 
 #define CUBEB_STREAM_MAX 32
 #define NBUFS 4
 
-const GUID KSDATAFORMAT_SUBTYPE_PCM =
-{ 0x00000001, 0x0000, 0x0010, { 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 } };
-const GUID KSDATAFORMAT_SUBTYPE_IEEE_FLOAT =
-{ 0x00000003, 0x0000, 0x0010, { 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 } };
+const GUID KSDATAFORMAT_SUBTYPE_PCM = {
+    0x00000001,
+    0x0000,
+    0x0010,
+    {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}};
+const GUID KSDATAFORMAT_SUBTYPE_IEEE_FLOAT = {
+    0x00000003,
+    0x0000,
+    0x0010,
+    {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}};
 
 struct cubeb_stream_item {
   SLIST_ENTRY head;
@@ -175,7 +182,7 @@ winmm_refill_stream(cubeb_stream * stm)
 
   hdr = winmm_get_next_buffer(stm);
 
-  wanted = (DWORD) stm->buffer_size / bytes_per_frame(stm->params);
+  wanted = (DWORD)stm->buffer_size / bytes_per_frame(stm->params);
 
   /* It is assumed that the caller is holding this lock.  It must be dropped
      during the callback to avoid deadlocks. */
@@ -199,16 +206,16 @@ winmm_refill_stream(cubeb_stream * stm)
 
   if (stm->soft_volume != -1.0) {
     if (stm->params.format == CUBEB_SAMPLE_FLOAT32NE) {
-      float * b = (float *) hdr->lpData;
+      float * b = (float *)hdr->lpData;
       uint32_t i;
       for (i = 0; i < got * stm->params.channels; i++) {
         b[i] *= stm->soft_volume;
       }
     } else {
-      short * b = (short *) hdr->lpData;
+      short * b = (short *)hdr->lpData;
       uint32_t i;
       for (i = 0; i < got * stm->params.channels; i++) {
-        b[i] = (short) (b[i] * stm->soft_volume);
+        b[i] = (short)(b[i] * stm->soft_volume);
       }
     }
   }
@@ -223,10 +230,9 @@ winmm_refill_stream(cubeb_stream * stm)
   LeaveCriticalSection(&stm->lock);
 }
 
-static unsigned __stdcall
-winmm_buffer_thread(void * user_ptr)
+static unsigned __stdcall winmm_buffer_thread(void * user_ptr)
 {
-  cubeb * ctx = (cubeb *) user_ptr;
+  cubeb * ctx = (cubeb *)user_ptr;
   XASSERT(ctx);
 
   for (;;) {
@@ -242,7 +248,7 @@ winmm_buffer_thread(void * user_ptr)
     item = InterlockedFlushSList(ctx->work);
     while (item != NULL) {
       PSLIST_ENTRY tmp = item;
-      winmm_refill_stream(((struct cubeb_stream_item *) tmp)->stream);
+      winmm_refill_stream(((struct cubeb_stream_item *)tmp)->stream);
       item = item->Next;
       _aligned_free(tmp);
     }
@@ -256,16 +262,18 @@ winmm_buffer_thread(void * user_ptr)
 }
 
 static void CALLBACK
-winmm_buffer_callback(HWAVEOUT waveout, UINT msg, DWORD_PTR user_ptr, DWORD_PTR p1, DWORD_PTR p2)
+winmm_buffer_callback(HWAVEOUT waveout, UINT msg, DWORD_PTR user_ptr,
+                      DWORD_PTR p1, DWORD_PTR p2)
 {
-  cubeb_stream * stm = (cubeb_stream *) user_ptr;
+  cubeb_stream * stm = (cubeb_stream *)user_ptr;
   struct cubeb_stream_item * item;
 
   if (msg != WOM_DONE) {
     return;
   }
 
-  item = _aligned_malloc(sizeof(struct cubeb_stream_item), MEMORY_ALLOCATION_ALIGNMENT);
+  item = _aligned_malloc(sizeof(struct cubeb_stream_item),
+                         MEMORY_ALLOCATION_ALIGNMENT);
   XASSERT(item);
   item->stream = stm;
   InterlockedPushEntrySList(stm->context->work, &item->head);
@@ -284,7 +292,8 @@ calculate_minimum_latency(void)
     return 500;
   }
 
-  /* Vista's WinMM implementation underruns when less than 200ms of audio is buffered. */
+  /* Vista's WinMM implementation underruns when less than 200ms of audio is
+   * buffered. */
   memset(&osvi, 0, sizeof(OSVERSIONINFOEX));
   osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
   osvi.dwMajorVersion = 6;
@@ -294,14 +303,16 @@ calculate_minimum_latency(void)
   VER_SET_CONDITION(mask, VER_MAJORVERSION, VER_EQUAL);
   VER_SET_CONDITION(mask, VER_MINORVERSION, VER_EQUAL);
 
-  if (VerifyVersionInfo(&osvi, VER_MAJORVERSION | VER_MINORVERSION, mask) != 0) {
+  if (VerifyVersionInfo(&osvi, VER_MAJORVERSION | VER_MINORVERSION, mask) !=
+      0) {
     return 200;
   }
 
   return 100;
 }
 
-static void winmm_destroy(cubeb * ctx);
+static void
+winmm_destroy(cubeb * ctx);
 
 /*static*/ int
 winmm_init(cubeb ** context, char const * context_name)
@@ -331,7 +342,9 @@ winmm_init(cubeb ** context, char const * context_name)
     return CUBEB_ERROR;
   }
 
-  ctx->thread = (HANDLE) _beginthreadex(NULL, 256 * 1024, winmm_buffer_thread, ctx, STACK_SIZE_PARAM_IS_A_RESERVATION, NULL);
+  ctx->thread =
+      (HANDLE)_beginthreadex(NULL, 256 * 1024, winmm_buffer_thread, ctx,
+                             STACK_SIZE_PARAM_IS_A_RESERVATION, NULL);
   if (!ctx->thread) {
     winmm_destroy(ctx);
     return CUBEB_ERROR;
@@ -382,18 +395,18 @@ winmm_destroy(cubeb * ctx)
   free(ctx);
 }
 
-static void winmm_stream_destroy(cubeb_stream * stm);
+static void
+winmm_stream_destroy(cubeb_stream * stm);
 
 static int
-winmm_stream_init(cubeb * context, cubeb_stream ** stream, char const * stream_name,
-                  cubeb_devid input_device,
+winmm_stream_init(cubeb * context, cubeb_stream ** stream,
+                  char const * stream_name, cubeb_devid input_device,
                   cubeb_stream_params * input_stream_params,
                   cubeb_devid output_device,
                   cubeb_stream_params * output_stream_params,
                   unsigned int latency_frames,
                   cubeb_data_callback data_callback,
-                  cubeb_state_callback state_callback,
-                  void * user_ptr)
+                  cubeb_state_callback state_callback, void * user_ptr)
 {
   MMRESULT r;
   WAVEFORMATEXTENSIBLE wfx;
@@ -452,8 +465,10 @@ winmm_stream_init(cubeb * context, cubeb_stream ** stream, char const * stream_n
     return CUBEB_ERROR_INVALID_FORMAT;
   }
 
-  wfx.Format.nBlockAlign = (wfx.Format.wBitsPerSample * wfx.Format.nChannels) / 8;
-  wfx.Format.nAvgBytesPerSec = wfx.Format.nSamplesPerSec * wfx.Format.nBlockAlign;
+  wfx.Format.nBlockAlign =
+      (wfx.Format.wBitsPerSample * wfx.Format.nChannels) / 8;
+  wfx.Format.nAvgBytesPerSec =
+      wfx.Format.nSamplesPerSec * wfx.Format.nBlockAlign;
   wfx.Samples.wValidBitsPerSample = wfx.Format.wBitsPerSample;
 
   EnterCriticalSection(&context->lock);
@@ -485,9 +500,11 @@ winmm_stream_init(cubeb * context, cubeb_stream ** stream, char const * stream_n
     latency_ms = context->minimum_latency_ms;
   }
 
-  bufsz = (size_t) (stm->params.rate / 1000.0 * latency_ms * bytes_per_frame(stm->params) / NBUFS);
+  bufsz = (size_t)(stm->params.rate / 1000.0 * latency_ms *
+                   bytes_per_frame(stm->params) / NBUFS);
   if (bufsz % bytes_per_frame(stm->params) != 0) {
-    bufsz += bytes_per_frame(stm->params) - (bufsz % bytes_per_frame(stm->params));
+    bufsz +=
+        bytes_per_frame(stm->params) - (bufsz % bytes_per_frame(stm->params));
   }
   XASSERT(bufsz % bytes_per_frame(stm->params) == 0);
 
@@ -506,7 +523,7 @@ winmm_stream_init(cubeb * context, cubeb_stream ** stream, char const * stream_n
   /* winmm_buffer_callback will be called during waveOutOpen, so all
      other initialization must be complete before calling it. */
   r = waveOutOpen(&stm->waveout, WAVE_MAPPER, &wfx.Format,
-                  (DWORD_PTR) winmm_buffer_callback, (DWORD_PTR) stm,
+                  (DWORD_PTR)winmm_buffer_callback, (DWORD_PTR)stm,
                   CALLBACK_FUNCTION);
   if (r != MMSYSERR_NOERROR) {
     winmm_stream_destroy(stm);
@@ -580,7 +597,8 @@ winmm_stream_destroy(cubeb_stream * stm)
 
     for (i = 0; i < NBUFS; ++i) {
       if (stm->buffers[i].dwFlags & WHDR_PREPARED) {
-        waveOutUnprepareHeader(stm->waveout, &stm->buffers[i], sizeof(stm->buffers[i]));
+        waveOutUnprepareHeader(stm->waveout, &stm->buffers[i],
+                               sizeof(stm->buffers[i]));
       }
     }
 
@@ -619,7 +637,8 @@ winmm_get_max_channel_count(cubeb * ctx, uint32_t * max_channels)
 }
 
 static int
-winmm_get_min_latency(cubeb * ctx, cubeb_stream_params params, uint32_t * latency)
+winmm_get_min_latency(cubeb * ctx, cubeb_stream_params params,
+                      uint32_t * latency)
 {
   // 100ms minimum, if we are not in a bizarre configuration.
   *latency = ctx->minimum_latency_ms * params.rate / 1000;
@@ -724,7 +743,7 @@ winmm_stream_get_latency(cubeb_stream * stm, uint32_t * latency)
   }
 
   XASSERT(written - time.u.sample <= UINT32_MAX);
-  *latency = (uint32_t) (written - time.u.sample);
+  *latency = (uint32_t)(written - time.u.sample);
 
   return CUBEB_OK;
 }
@@ -738,11 +757,18 @@ winmm_stream_set_volume(cubeb_stream * stm, float volume)
   return CUBEB_OK;
 }
 
-#define MM_11025HZ_MASK (WAVE_FORMAT_1M08 | WAVE_FORMAT_1M16 | WAVE_FORMAT_1S08 | WAVE_FORMAT_1S16)
-#define MM_22050HZ_MASK (WAVE_FORMAT_2M08 | WAVE_FORMAT_2M16 | WAVE_FORMAT_2S08 | WAVE_FORMAT_2S16)
-#define MM_44100HZ_MASK (WAVE_FORMAT_4M08 | WAVE_FORMAT_4M16 | WAVE_FORMAT_4S08 | WAVE_FORMAT_4S16)
-#define MM_48000HZ_MASK (WAVE_FORMAT_48M08 | WAVE_FORMAT_48M16 | WAVE_FORMAT_48S08 | WAVE_FORMAT_48S16)
-#define MM_96000HZ_MASK (WAVE_FORMAT_96M08 | WAVE_FORMAT_96M16 | WAVE_FORMAT_96S08 | WAVE_FORMAT_96S16)
+#define MM_11025HZ_MASK                                                        \
+  (WAVE_FORMAT_1M08 | WAVE_FORMAT_1M16 | WAVE_FORMAT_1S08 | WAVE_FORMAT_1S16)
+#define MM_22050HZ_MASK                                                        \
+  (WAVE_FORMAT_2M08 | WAVE_FORMAT_2M16 | WAVE_FORMAT_2S08 | WAVE_FORMAT_2S16)
+#define MM_44100HZ_MASK                                                        \
+  (WAVE_FORMAT_4M08 | WAVE_FORMAT_4M16 | WAVE_FORMAT_4S08 | WAVE_FORMAT_4S16)
+#define MM_48000HZ_MASK                                                        \
+  (WAVE_FORMAT_48M08 | WAVE_FORMAT_48M16 | WAVE_FORMAT_48S08 |                 \
+   WAVE_FORMAT_48S16)
+#define MM_96000HZ_MASK                                                        \
+  (WAVE_FORMAT_96M08 | WAVE_FORMAT_96M16 | WAVE_FORMAT_96S08 |                 \
+   WAVE_FORMAT_96S16)
 static void
 winmm_calculate_device_rate(cubeb_device_info * info, DWORD formats)
 {
@@ -752,17 +778,20 @@ winmm_calculate_device_rate(cubeb_device_info * info, DWORD formats)
     info->max_rate = 11025;
   }
   if (formats & MM_22050HZ_MASK) {
-    if (info->min_rate == 0) info->min_rate = 22050;
+    if (info->min_rate == 0)
+      info->min_rate = 22050;
     info->max_rate = 22050;
     info->default_rate = 22050;
   }
   if (formats & MM_44100HZ_MASK) {
-    if (info->min_rate == 0) info->min_rate = 44100;
+    if (info->min_rate == 0)
+      info->min_rate = 44100;
     info->max_rate = 44100;
     info->default_rate = 44100;
   }
   if (formats & MM_48000HZ_MASK) {
-    if (info->min_rate == 0) info->min_rate = 48000;
+    if (info->min_rate == 0)
+      info->min_rate = 48000;
     info->max_rate = 48000;
     info->default_rate = 48000;
   }
@@ -775,11 +804,14 @@ winmm_calculate_device_rate(cubeb_device_info * info, DWORD formats)
   }
 }
 
-#define MM_S16_MASK (WAVE_FORMAT_1M16 | WAVE_FORMAT_1S16 | WAVE_FORMAT_2M16 | WAVE_FORMAT_2S16 | WAVE_FORMAT_4M16 | \
-    WAVE_FORMAT_4S16 | WAVE_FORMAT_48M16 | WAVE_FORMAT_48S16 | WAVE_FORMAT_96M16 | WAVE_FORMAT_96S16)
+#define MM_S16_MASK                                                            \
+  (WAVE_FORMAT_1M16 | WAVE_FORMAT_1S16 | WAVE_FORMAT_2M16 | WAVE_FORMAT_2S16 | \
+   WAVE_FORMAT_4M16 | WAVE_FORMAT_4S16 | WAVE_FORMAT_48M16 |                   \
+   WAVE_FORMAT_48S16 | WAVE_FORMAT_96M16 | WAVE_FORMAT_96S16)
 static int
 winmm_query_supported_formats(UINT devid, DWORD formats,
-    cubeb_device_fmt * supfmt, cubeb_device_fmt * deffmt)
+                              cubeb_device_fmt * supfmt,
+                              cubeb_device_fmt * deffmt)
 {
   WAVEFORMATEXTENSIBLE wfx;
 
@@ -793,13 +825,16 @@ winmm_query_supported_formats(UINT devid, DWORD formats,
   wfx.Format.nChannels = 2;
   wfx.Format.nSamplesPerSec = 44100;
   wfx.Format.wBitsPerSample = 32;
-  wfx.Format.nBlockAlign = (wfx.Format.wBitsPerSample * wfx.Format.nChannels) / 8;
-  wfx.Format.nAvgBytesPerSec = wfx.Format.nSamplesPerSec * wfx.Format.nBlockAlign;
+  wfx.Format.nBlockAlign =
+      (wfx.Format.wBitsPerSample * wfx.Format.nChannels) / 8;
+  wfx.Format.nAvgBytesPerSec =
+      wfx.Format.nSamplesPerSec * wfx.Format.nBlockAlign;
   wfx.Format.cbSize = 22;
   wfx.Samples.wValidBitsPerSample = wfx.Format.wBitsPerSample;
   wfx.dwChannelMask = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT;
   wfx.SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
-  if (waveOutOpen(NULL, devid, &wfx.Format, 0, 0, WAVE_FORMAT_QUERY) == MMSYSERR_NOERROR)
+  if (waveOutOpen(NULL, devid, &wfx.Format, 0, 0, WAVE_FORMAT_QUERY) ==
+      MMSYSERR_NOERROR)
     *supfmt = (cubeb_device_fmt)(*supfmt | CUBEB_DEVICE_FMT_F32LE);
 
   return (*deffmt != 0) ? CUBEB_OK : CUBEB_ERROR;
@@ -813,10 +848,10 @@ guid_to_cstr(LPGUID guid)
     return NULL;
   }
   _snprintf_s(ret, 40, _TRUNCATE,
-      "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
-      guid->Data1, guid->Data2, guid->Data3,
-      guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
-      guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]);
+              "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}", guid->Data1,
+              guid->Data2, guid->Data3, guid->Data4[0], guid->Data4[1],
+              guid->Data4[2], guid->Data4[3], guid->Data4[4], guid->Data4[5],
+              guid->Data4[6], guid->Data4[7]);
   return ret;
 }
 
@@ -826,13 +861,15 @@ winmm_query_preferred_out_device(UINT devid)
   DWORD mmpref = WAVE_MAPPER, compref = WAVE_MAPPER, status;
   cubeb_device_pref ret = CUBEB_DEVICE_PREF_NONE;
 
-  if (waveOutMessage((HWAVEOUT) WAVE_MAPPER, DRVM_MAPPER_PREFERRED_GET,
-        (DWORD_PTR)&mmpref, (DWORD_PTR)&status) == MMSYSERR_NOERROR &&
+  if (waveOutMessage((HWAVEOUT)WAVE_MAPPER, DRVM_MAPPER_PREFERRED_GET,
+                     (DWORD_PTR)&mmpref,
+                     (DWORD_PTR)&status) == MMSYSERR_NOERROR &&
       devid == mmpref)
     ret |= CUBEB_DEVICE_PREF_MULTIMEDIA | CUBEB_DEVICE_PREF_NOTIFICATION;
 
-  if (waveOutMessage((HWAVEOUT) WAVE_MAPPER, DRVM_MAPPER_CONSOLEVOICECOM_GET,
-        (DWORD_PTR)&compref, (DWORD_PTR)&status) == MMSYSERR_NOERROR &&
+  if (waveOutMessage((HWAVEOUT)WAVE_MAPPER, DRVM_MAPPER_CONSOLEVOICECOM_GET,
+                     (DWORD_PTR)&compref,
+                     (DWORD_PTR)&status) == MMSYSERR_NOERROR &&
       devid == compref)
     ret |= CUBEB_DEVICE_PREF_VOICE;
 
@@ -851,10 +888,11 @@ device_id_idx(UINT devid)
 }
 
 static void
-winmm_create_device_from_outcaps2(cubeb_device_info * ret, LPWAVEOUTCAPS2A caps, UINT devid)
+winmm_create_device_from_outcaps2(cubeb_device_info * ret, LPWAVEOUTCAPS2A caps,
+                                  UINT devid)
 {
   XASSERT(ret);
-  ret->devid = (cubeb_devid) devid;
+  ret->devid = (cubeb_devid)devid;
   ret->device_id = device_id_idx(devid);
   ret->friendly_name = _strdup(caps->szPname);
   ret->group_id = guid_to_cstr(&caps->ProductGuid);
@@ -866,8 +904,8 @@ winmm_create_device_from_outcaps2(cubeb_device_info * ret, LPWAVEOUTCAPS2A caps,
 
   ret->max_channels = caps->wChannels;
   winmm_calculate_device_rate(ret, caps->dwFormats);
-  winmm_query_supported_formats(devid, caps->dwFormats,
-      &ret->format, &ret->default_format);
+  winmm_query_supported_formats(devid, caps->dwFormats, &ret->format,
+                                &ret->default_format);
 
   /* Hardcoded latency estimates... */
   ret->latency_lo = 100 * ret->default_rate / 1000;
@@ -875,10 +913,11 @@ winmm_create_device_from_outcaps2(cubeb_device_info * ret, LPWAVEOUTCAPS2A caps,
 }
 
 static void
-winmm_create_device_from_outcaps(cubeb_device_info * ret, LPWAVEOUTCAPSA caps, UINT devid)
+winmm_create_device_from_outcaps(cubeb_device_info * ret, LPWAVEOUTCAPSA caps,
+                                 UINT devid)
 {
   XASSERT(ret);
-  ret->devid = (cubeb_devid) devid;
+  ret->devid = (cubeb_devid)devid;
   ret->device_id = device_id_idx(devid);
   ret->friendly_name = _strdup(caps->szPname);
   ret->group_id = NULL;
@@ -890,8 +929,8 @@ winmm_create_device_from_outcaps(cubeb_device_info * ret, LPWAVEOUTCAPSA caps, U
 
   ret->max_channels = caps->wChannels;
   winmm_calculate_device_rate(ret, caps->dwFormats);
-  winmm_query_supported_formats(devid, caps->dwFormats,
-      &ret->format, &ret->default_format);
+  winmm_query_supported_formats(devid, caps->dwFormats, &ret->format,
+                                &ret->default_format);
 
   /* Hardcoded latency estimates... */
   ret->latency_lo = 100 * ret->default_rate / 1000;
@@ -904,13 +943,15 @@ winmm_query_preferred_in_device(UINT devid)
   DWORD mmpref = WAVE_MAPPER, compref = WAVE_MAPPER, status;
   cubeb_device_pref ret = CUBEB_DEVICE_PREF_NONE;
 
-  if (waveInMessage((HWAVEIN) WAVE_MAPPER, DRVM_MAPPER_PREFERRED_GET,
-        (DWORD_PTR)&mmpref, (DWORD_PTR)&status) == MMSYSERR_NOERROR &&
+  if (waveInMessage((HWAVEIN)WAVE_MAPPER, DRVM_MAPPER_PREFERRED_GET,
+                    (DWORD_PTR)&mmpref,
+                    (DWORD_PTR)&status) == MMSYSERR_NOERROR &&
       devid == mmpref)
     ret |= CUBEB_DEVICE_PREF_MULTIMEDIA | CUBEB_DEVICE_PREF_NOTIFICATION;
 
-  if (waveInMessage((HWAVEIN) WAVE_MAPPER, DRVM_MAPPER_CONSOLEVOICECOM_GET,
-        (DWORD_PTR)&compref, (DWORD_PTR)&status) == MMSYSERR_NOERROR &&
+  if (waveInMessage((HWAVEIN)WAVE_MAPPER, DRVM_MAPPER_CONSOLEVOICECOM_GET,
+                    (DWORD_PTR)&compref,
+                    (DWORD_PTR)&status) == MMSYSERR_NOERROR &&
       devid == compref)
     ret |= CUBEB_DEVICE_PREF_VOICE;
 
@@ -918,10 +959,11 @@ winmm_query_preferred_in_device(UINT devid)
 }
 
 static void
-winmm_create_device_from_incaps2(cubeb_device_info * ret, LPWAVEINCAPS2A caps, UINT devid)
+winmm_create_device_from_incaps2(cubeb_device_info * ret, LPWAVEINCAPS2A caps,
+                                 UINT devid)
 {
   XASSERT(ret);
-  ret->devid = (cubeb_devid) devid;
+  ret->devid = (cubeb_devid)devid;
   ret->device_id = device_id_idx(devid);
   ret->friendly_name = _strdup(caps->szPname);
   ret->group_id = guid_to_cstr(&caps->ProductGuid);
@@ -933,8 +975,8 @@ winmm_create_device_from_incaps2(cubeb_device_info * ret, LPWAVEINCAPS2A caps, U
 
   ret->max_channels = caps->wChannels;
   winmm_calculate_device_rate(ret, caps->dwFormats);
-  winmm_query_supported_formats(devid, caps->dwFormats,
-      &ret->format, &ret->default_format);
+  winmm_query_supported_formats(devid, caps->dwFormats, &ret->format,
+                                &ret->default_format);
 
   /* Hardcoded latency estimates... */
   ret->latency_lo = 100 * ret->default_rate / 1000;
@@ -942,10 +984,11 @@ winmm_create_device_from_incaps2(cubeb_device_info * ret, LPWAVEINCAPS2A caps, U
 }
 
 static void
-winmm_create_device_from_incaps(cubeb_device_info * ret, LPWAVEINCAPSA caps, UINT devid)
+winmm_create_device_from_incaps(cubeb_device_info * ret, LPWAVEINCAPSA caps,
+                                UINT devid)
 {
   XASSERT(ret);
-  ret->devid = (cubeb_devid) devid;
+  ret->devid = (cubeb_devid)devid;
   ret->device_id = device_id_idx(devid);
   ret->friendly_name = _strdup(caps->szPname);
   ret->group_id = NULL;
@@ -957,8 +1000,8 @@ winmm_create_device_from_incaps(cubeb_device_info * ret, LPWAVEINCAPSA caps, UIN
 
   ret->max_channels = caps->wChannels;
   winmm_calculate_device_rate(ret, caps->dwFormats);
-  winmm_query_supported_formats(devid, caps->dwFormats,
-      &ret->format, &ret->default_format);
+  winmm_query_supported_formats(devid, caps->dwFormats, &ret->format,
+                                &ret->default_format);
 
   /* Hardcoded latency estimates... */
   ret->latency_lo = 100 * ret->default_rate / 1000;
@@ -989,7 +1032,8 @@ winmm_enumerate_devices(cubeb * context, cubeb_device_type type,
 
     for (i = 0; i < outcount; i++) {
       dev = &devices[collection->count];
-      if (waveOutGetDevCapsA(i, (LPWAVEOUTCAPSA)&woc2, sizeof(woc2)) == MMSYSERR_NOERROR) {
+      if (waveOutGetDevCapsA(i, (LPWAVEOUTCAPSA)&woc2, sizeof(woc2)) ==
+          MMSYSERR_NOERROR) {
         winmm_create_device_from_outcaps2(dev, &woc2, i);
         collection->count += 1;
       } else if (waveOutGetDevCapsA(i, &woc, sizeof(woc)) == MMSYSERR_NOERROR) {
@@ -1008,7 +1052,8 @@ winmm_enumerate_devices(cubeb * context, cubeb_device_type type,
 
     for (i = 0; i < incount; i++) {
       dev = &devices[collection->count];
-      if (waveInGetDevCapsA(i, (LPWAVEINCAPSA)&wic2, sizeof(wic2)) == MMSYSERR_NOERROR) {
+      if (waveInGetDevCapsA(i, (LPWAVEINCAPSA)&wic2, sizeof(wic2)) ==
+          MMSYSERR_NOERROR) {
         winmm_create_device_from_incaps2(dev, &wic2, i);
         collection->count += 1;
       } else if (waveInGetDevCapsA(i, &wic, sizeof(wic)) == MMSYSERR_NOERROR) {
@@ -1030,13 +1075,13 @@ winmm_device_collection_destroy(cubeb * ctx,
   uint32_t i;
   XASSERT(collection);
 
-  (void) ctx;
+  (void)ctx;
 
   for (i = 0; i < collection->count; i++) {
-    free((void *) collection->device[i].device_id);
-    free((void *) collection->device[i].friendly_name);
-    free((void *) collection->device[i].group_id);
-    free((void *) collection->device[i].vendor_name);
+    free((void *)collection->device[i].device_id);
+    free((void *)collection->device[i].friendly_name);
+    free((void *)collection->device[i].group_id);
+    free((void *)collection->device[i].vendor_name);
   }
 
   free(collection->device);
@@ -1044,25 +1089,24 @@ winmm_device_collection_destroy(cubeb * ctx,
 }
 
 static struct cubeb_ops const winmm_ops = {
-  /*.init =*/ winmm_init,
-  /*.get_backend_id =*/ winmm_get_backend_id,
-  /*.get_max_channel_count=*/ winmm_get_max_channel_count,
-  /*.get_min_latency=*/ winmm_get_min_latency,
-  /*.get_preferred_sample_rate =*/ winmm_get_preferred_sample_rate,
-  /*.enumerate_devices =*/ winmm_enumerate_devices,
-  /*.device_collection_destroy =*/ winmm_device_collection_destroy,
-  /*.destroy =*/ winmm_destroy,
-  /*.stream_init =*/ winmm_stream_init,
-  /*.stream_destroy =*/ winmm_stream_destroy,
-  /*.stream_start =*/ winmm_stream_start,
-  /*.stream_stop =*/ winmm_stream_stop,
-  /*.stream_get_position =*/ winmm_stream_get_position,
-  /*.stream_get_latency = */ winmm_stream_get_latency,
-  /*.stream_get_input_latency = */ NULL,
-  /*.stream_set_volume =*/ winmm_stream_set_volume,
-  /*.stream_set_name =*/ NULL,
-  /*.stream_get_current_device =*/ NULL,
-  /*.stream_device_destroy =*/ NULL,
-  /*.stream_register_device_changed_callback=*/ NULL,
-  /*.register_device_collection_changed =*/ NULL
-};
+    /*.init =*/winmm_init,
+    /*.get_backend_id =*/winmm_get_backend_id,
+    /*.get_max_channel_count=*/winmm_get_max_channel_count,
+    /*.get_min_latency=*/winmm_get_min_latency,
+    /*.get_preferred_sample_rate =*/winmm_get_preferred_sample_rate,
+    /*.enumerate_devices =*/winmm_enumerate_devices,
+    /*.device_collection_destroy =*/winmm_device_collection_destroy,
+    /*.destroy =*/winmm_destroy,
+    /*.stream_init =*/winmm_stream_init,
+    /*.stream_destroy =*/winmm_stream_destroy,
+    /*.stream_start =*/winmm_stream_start,
+    /*.stream_stop =*/winmm_stream_stop,
+    /*.stream_get_position =*/winmm_stream_get_position,
+    /*.stream_get_latency = */ winmm_stream_get_latency,
+    /*.stream_get_input_latency = */ NULL,
+    /*.stream_set_volume =*/winmm_stream_set_volume,
+    /*.stream_set_name =*/NULL,
+    /*.stream_get_current_device =*/NULL,
+    /*.stream_device_destroy =*/NULL,
+    /*.stream_register_device_changed_callback=*/NULL,
+    /*.register_device_collection_changed =*/NULL};