File firefox-900-libcubeb-with-jack-support_20160803... of Package MozillaFirefox

Overview Repositories Revisions Requests Users Attributes Meta

File firefox-900-libcubeb-with-jack-support_20160803.patch of Package MozillaFirefox (Revision c25a31b6c46be19859d4b57698d5c9a7)

Currently displaying revision c25a31b6c46be19859d4b57698d5c9a7 , Show latest

diff -Naur cubeb-firefox/config/system-headers cubeb-upstream/config/system-headers
--- cubeb-firefox/config/system-headers	2016-07-31 15:20:21.000000000 +0500
+++ cubeb-upstream/config/system-headers	2016-08-03 04:28:43.317216242 +0500
@@ -569,6 +569,10 @@
 iostream.h
 istream
 iterator
+#if MOZ_JACK==1
+jack/jack.h
+jack/statistics.h
+#endif
 JavaControl.h
 JavaEmbedding/JavaControl.h
 JavaVM/jni.h
diff -Naur cubeb-firefox/media/libcubeb/include/cubeb.h cubeb-upstream/media/libcubeb/include/cubeb.h
--- cubeb-firefox/media/libcubeb/include/cubeb.h	2016-07-31 15:20:25.000000000 +0500
+++ cubeb-upstream/media/libcubeb/include/cubeb.h	2016-08-03 04:39:35.679811097 +0500
@@ -19,44 +19,86 @@
 
     This is the documentation for the <tt>libcubeb</tt> C API.
     <tt>libcubeb</tt> is a callback-based audio API library allowing the
-    authoring of portable multiplatform audio playback.
+    authoring of portable multiplatform audio playback and recording.
 
     @section example Example code
 
+    This example shows how to create a duplex stream that pipes the microphone
+    to the speakers, with minimal latency and the proper sample-rate for the
+    platform.
+
     @code
     cubeb * app_ctx;
     cubeb_init(&app_ctx, "Example Application");
+    int rv;
+    int rate;
+    int latency_frames;
+    uint64_t ts;
+
+    rv = cubeb_get_min_latency(app_ctx, output_params, &latency_frames);
+    if (rv != CUBEB_OK) {
+      fprintf(stderr, "Could not get minimum latency");
+      return rv;
+    }
 
-    cubeb_stream_params params;
-    params.format = CUBEB_SAMPLE_S16NE;
-    params.rate = 48000;
-    params.channels = 2;
+    rv = cubeb_get_preferred_sample_rate(app_ctx, output_params, &rate);
+    if (rv != CUBEB_OK) {
+      fprintf(stderr, "Could not get preferred sample-rate");
+      return rv;
+    }
 
-    unsigned int latency_ms = 250;
+    cubeb_stream_params output_params;
+    output_params.format = CUBEB_SAMPLE_FLOAT32NE;
+    output_params.rate = rate;
+    output_params.channels = 2;
+
+    cubeb_stream_params input_params;
+    output_params.format = CUBEB_SAMPLE_FLOAT32NE;
+    output_params.rate = rate;
+    output_params.channels = 1;
 
     cubeb_stream * stm;
-    cubeb_stream_init(app_ctx, &stm, "Example Stream 1", params,
-                      latency_ms, data_cb, state_cb, NULL);
+    rv = cubeb_stream_init(app_ctx, &stm, "Example Stream 1",
+                           NULL, input_params,
+                           NULL, output_params,
+                           latency_frames,
+                           data_cb, state_cb,
+                           NULL);
+    if (rv != CUBEB_OK) {
+      fprintf(stderr, "Could not open the stream");
+      return rv;
+    }
 
-    cubeb_stream_start(stm);
+    rv = cubeb_stream_start(stm);
+    if (rv != CUBEB_OK) {
+      fprintf(stderr, "Could not start the stream");
+      return rv;
+    }
     for (;;) {
       cubeb_stream_get_position(stm, &ts);
       printf("time=%llu\n", ts);
       sleep(1);
     }
-    cubeb_stream_stop(stm);
+    rv = cubeb_stream_stop(stm);
+    if (rv != CUBEB_OK) {
+      fprintf(stderr, "Could not stop the stream");
+      return rv;
+    }
 
     cubeb_stream_destroy(stm);
     cubeb_destroy(app_ctx);
     @endcode
 
     @code
-    long data_cb(cubeb_stream * stm, void * user, void * buffer, long nframes)
+    long data_cb(cubeb_stream * stm, void * user,
+                 void * input_buffer, void * output_buffer, long nframes)
     {
-      short * buf = buffer;
+      float * in  = input_buffer;
+      float * out = output_buffer;
+
       for (i = 0; i < nframes; ++i) {
-        for (c = 0; c < params.channels; ++c) {
-          buf[i][c] = 0;
+        for (c = 0; c < 2; ++c) {
+          buf[i][c] = in[i];
         }
       }
       return nframes;
@@ -101,6 +143,10 @@
 } cubeb_sample_format;
 
 #if defined(__ANDROID__)
+/**
+ * This maps to the underlying stream types on supported platforms, e.g.
+ * Android.
+ */
 typedef enum {
     CUBEB_STREAM_TYPE_VOICE_CALL = 0,
     CUBEB_STREAM_TYPE_SYSTEM = 1,
@@ -133,7 +179,7 @@
 #endif
 } cubeb_stream_params;
 
-/** Output device description */
+/** Audio device description */
 typedef struct {
   char * output_name; /**< The name of the output device */
   char * input_name; /**< The name of the input device */
@@ -238,8 +284,8 @@
   unsigned int max_rate;      /**< Maximum sample rate supported. */
   unsigned int min_rate;      /**< Minimum sample rate supported. */
 
-  unsigned int latency_lo_ms; /**< Lowest possible latency in milliseconds. */
-  unsigned int latency_hi_ms; /**< Higest possible latency in milliseconds. */
+  unsigned int latency_lo; /**< Lowest possible latency in frames. */
+  unsigned int latency_hi; /**< Higest possible latency in frames. */
 } cubeb_device_info;
 
 /** Device collection. */
@@ -249,15 +295,21 @@
 } cubeb_device_collection;
 
 /** User supplied data callback.
-    @param stream The stream for which this callback fired
-    @param user_ptr The pointer passed to cubeb_stream_create
+    - Calling other cubeb functions from this callback is unsafe.
+    - The code in the callback should be non-blocking.
+    - Returning less than the number of frames this callback asks for or
+      provides puts the stream in drain mode. This callback will not be called
+      again, and the state callback will be called with CUBEB_STATE_DRAINED when
+      all the frames have been output.
+    @param stream The stream for which this callback fired.
+    @param user_ptr The pointer passed to cubeb_stream_init.
     @param input_buffer A pointer containing the input data, or nullptr
                         if this is an output-only stream.
-    @param output_buffer A pointer containing the output data, or nullptr
-                         if this is an input -only stream.
+    @param output_buffer A pointer to a buffer to be filled with audio samples,
+                         or nullptr if this is an input-only stream.
     @param nframes The number of frames of the two buffer.
-    @retval Number of frames written to the output buffer, which must equal
-            nframes except at end of stream.
+    @retval Number of frames written to the output buffer. If this number is
+            less than nframes, then the stream will start to drain.
     @retval CUBEB_ERROR on error, in which case the data callback will stop
             and the stream will enter a shutdown state. */
 typedef long (* cubeb_data_callback)(cubeb_stream * stream,
@@ -267,39 +319,43 @@
                                      long nframes);
 
 /** User supplied state callback.
-    @param stream
-    @param user_ptr
-    @param state */
+    @param stream The stream for this this callback fired.
+    @param user_ptr The pointer passed to cubeb_stream_init.
+    @param state The new state of the stream. */
 typedef void (* cubeb_state_callback)(cubeb_stream * stream,
                                       void * user_ptr,
                                       cubeb_state state);
 
 /**
  * User supplied callback called when the underlying device changed.
- * @param user */
+ * @param user The pointer passed to cubeb_stream_init. */
 typedef void (* cubeb_device_changed_callback)(void * user_ptr);
 
 /**
  * User supplied callback called when the underlying device collection changed.
- * @param context
- * @param user_ptr */
-typedef void (* cubeb_device_collection_changed_callback)(cubeb * context, void * user_ptr);
+ * @param context A pointer to the cubeb context.
+ * @param user_ptr The pointer passed to cubeb_stream_init. */
+typedef void (* cubeb_device_collection_changed_callback)(cubeb * context,
+                                                          void * user_ptr);
 
 /** Initialize an application context.  This will perform any library or
     application scoped initialization.
-    @param context
-    @param context_name
-    @retval CUBEB_OK
-    @retval CUBEB_ERROR */
+    @param context A out param where an opaque pointer to the application
+                   context will be returned.
+    @param context_name A name for the context. Depending on the platform this
+                        can appear in different locations.
+    @retval CUBEB_OK in case of success.
+    @retval CUBEB_ERROR in case of error, for example because the host
+                        has no audio hardware. */
 int cubeb_init(cubeb ** context, char const * context_name);
 
 /** Get a read-only string identifying this context's current backend.
-    @param context
+    @param context A pointer to the cubeb context.
     @retval Read-only string identifying current backend. */
 char const * cubeb_get_backend_id(cubeb * context);
 
 /** Get the maximum possible number of channels.
-    @param context
+    @param context A pointer to the cubeb context.
     @param max_channels The maximum number of channels.
     @retval CUBEB_OK
     @retval CUBEB_ERROR_INVALID_PARAMETER
@@ -307,51 +363,55 @@
     @retval CUBEB_ERROR */
 int cubeb_get_max_channel_count(cubeb * context, uint32_t * max_channels);
 
-/** Get the minimal latency value, in milliseconds, that is guaranteed to work
-    when creating a stream for the specified sample rate. This is platform and
-    backend dependant.
-    @param context
+/** Get the minimal latency value, in frames, that is guaranteed to work
+    when creating a stream for the specified sample rate. This is platform,
+    hardware and backend dependant.
+    @param context A pointer to the cubeb context.
     @param params On some backends, the minimum achievable latency depends on
                   the characteristics of the stream.
-    @param latency_ms The latency value, in ms, to pass to cubeb_stream_init.
+    @param latency_frames The latency value, in frames, to pass to
+                          cubeb_stream_init.
     @retval CUBEB_OK
     @retval CUBEB_ERROR_INVALID_PARAMETER
     @retval CUBEB_ERROR_NOT_SUPPORTED */
 int cubeb_get_min_latency(cubeb * context,
                           cubeb_stream_params params,
-                          uint32_t * latency_ms);
+                          uint32_t * latency_frames);
 
 /** Get the preferred sample rate for this backend: this is hardware and
     platform dependant, and can avoid resampling, and/or trigger fastpaths.
-    @param context
+    @param context A pointer to the cubeb context.
     @param rate The samplerate (in Hz) the current configuration prefers.
     @retval CUBEB_OK
     @retval CUBEB_ERROR_INVALID_PARAMETER
     @retval CUBEB_ERROR_NOT_SUPPORTED */
 int cubeb_get_preferred_sample_rate(cubeb * context, uint32_t * rate);
 
-/** Destroy an application context.
-    @param context */
+/** Destroy an application context. This must be called after all stream have
+ *  been destroyed.
+    @param context A pointer to the cubeb context.*/
 void cubeb_destroy(cubeb * context);
 
 /** Initialize a stream associated with the supplied application context.
-    @param context
-    @param stream
-    @param stream_name
-    @param input_device Device for the input side of the stream. If NULL
+    @param context A pointer to the cubeb context.
+    @param stream An out parameter to be filled with the an opaque pointer to a
+                  cubeb stream.
+    @param stream_name A name for this stream. 
+    @param input_device Device for the input side of the stream. If NULL the
                         default input device is used.
     @param input_stream_params Parameters for the input side of the stream, or
                                NULL if this stream is output only.
-    @param output_device Device for the output side of the stream. If NULL
+    @param output_device Device for the output side of the stream. If NULL the
                          default output device is used.
     @param output_stream_params Parameters for the output side of the stream, or
                                 NULL if this stream is input only.
-    @param latency Approximate stream latency in milliseconds.  Valid range
-                   is [1, 2000].
+    @param latency Stream latency in frames.  Valid range
+                   is [1, 96000].
     @param data_callback Will be called to preroll data before playback is
                          started by cubeb_stream_start.
-    @param state_callback
-    @param user_ptr
+    @param state_callback A pointer to a state callback.
+    @param user_ptr A pointer that will be passed to the callbacks. This pointer
+                    must outlive the life time of the stream.
     @retval CUBEB_OK
     @retval CUBEB_ERROR
     @retval CUBEB_ERROR_INVALID_FORMAT
@@ -363,13 +423,14 @@
                       cubeb_stream_params * input_stream_params,
                       cubeb_devid output_device,
                       cubeb_stream_params * output_stream_params,
-                      unsigned int latency,
+                      unsigned int latency_frames,
                       cubeb_data_callback data_callback,
                       cubeb_state_callback state_callback,
                       void * user_ptr);
 
-/** Destroy a stream.
-    @param stream */
+/** Destroy a stream. `cubeb_stream_stop` MUST be called before destroying a
+    stream.
+    @param stream The stream to destroy. */
 void cubeb_stream_destroy(cubeb_stream * stream);
 
 /** Start playback.
diff -Naur cubeb-firefox/media/libcubeb/README_MOZILLA cubeb-upstream/media/libcubeb/README_MOZILLA
--- cubeb-firefox/media/libcubeb/README_MOZILLA	2016-07-31 15:20:25.000000000 +0500
+++ cubeb-upstream/media/libcubeb/README_MOZILLA	2016-08-03 04:39:35.866802956 +0500
@@ -5,4 +5,4 @@
 
 The cubeb git repository is: git://github.com/kinetiknz/cubeb.git
 
-The git commit ID used was d654c426ef944f0a36e6da86c959d94271173cfb.
+The git commit ID used was 15dc54f87bbaa4f1357e257b0c003d46191c5cc8.
diff -Naur cubeb-firefox/media/libcubeb/src/cubeb_alsa.c cubeb-upstream/media/libcubeb/src/cubeb_alsa.c
--- cubeb-firefox/media/libcubeb/src/cubeb_alsa.c	2016-07-31 15:20:25.000000000 +0500
+++ cubeb-upstream/media/libcubeb/src/cubeb_alsa.c	2016-08-03 04:39:35.691810575 +0500
@@ -251,8 +251,6 @@
 static enum stream_state
 alsa_refill_stream(cubeb_stream * stm)
 {
-  int r;
-  unsigned short revents;
   snd_pcm_sframes_t avail;
   long got;
   void * p;
@@ -262,17 +260,8 @@
 
   pthread_mutex_lock(&stm->mutex);
 
-  r = snd_pcm_poll_descriptors_revents(stm->pcm, stm->fds, stm->nfds, &revents);
-  if (r < 0 || revents != POLLOUT) {
-    /* This should be a stream error; it makes no sense for poll(2) to wake
-       for this stream and then have the stream report that it's not ready.
-       Unfortunately, this does happen, so just bail out and try again. */
-    pthread_mutex_unlock(&stm->mutex);
-    return RUNNING;
-  }
-
   avail = snd_pcm_avail_update(stm->pcm);
-  if (avail == -EPIPE) {
+  if (avail < 0) {
     snd_pcm_recover(stm->pcm, avail, 1);
     avail = snd_pcm_avail_update(stm->pcm);
   }
@@ -291,15 +280,10 @@
 
   /* poll(2) claims this stream is active, so there should be some space
      available to write.  If avail is still zero here, the stream must be in
-     a funky state, so recover and try again. */
+     a funky state, bail and wait for another wakeup. */
   if (avail == 0) {
-    snd_pcm_recover(stm->pcm, -EPIPE, 1);
-    avail = snd_pcm_avail_update(stm->pcm);
-    if (avail <= 0) {
-      pthread_mutex_unlock(&stm->mutex);
-      stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_ERROR);
-      return ERROR;
-    }
+    pthread_mutex_unlock(&stm->mutex);
+    return RUNNING;
   }
 
   p = calloc(1, snd_pcm_frames_to_bytes(stm->pcm, avail));
@@ -311,6 +295,7 @@
   if (got < 0) {
     pthread_mutex_unlock(&stm->mutex);
     stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_ERROR);
+    free(p);
     return ERROR;
   }
   if (got > 0) {
@@ -328,7 +313,7 @@
       }
     }
     wrote = snd_pcm_writei(stm->pcm, p, got);
-    if (wrote == -EPIPE) {
+    if (wrote < 0) {
       snd_pcm_recover(stm->pcm, wrote, 1);
       wrote = snd_pcm_writei(stm->pcm, p, got);
     }
@@ -400,6 +385,8 @@
 
     for (i = 0; i < CUBEB_STREAM_MAX; ++i) {
       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)) {
         alsa_set_stream_state(stm, PROCESSING);
         pthread_mutex_unlock(&ctx->mutex);
@@ -785,7 +772,7 @@
                  cubeb_stream_params * input_stream_params,
                  cubeb_devid output_device,
                  cubeb_stream_params * output_stream_params,
-                 unsigned int latency,
+                 unsigned int latency_frames,
                  cubeb_data_callback data_callback, cubeb_state_callback state_callback,
                  void * user_ptr)
 {
@@ -793,10 +780,16 @@
   int r;
   snd_pcm_format_t format;
   snd_pcm_uframes_t period_size;
+  int latency_us = 0;
+
 
   assert(ctx && stream);
 
-  assert(!input_stream_params && "not supported.");
+  if (input_stream_params) {
+    /* Capture support not yet implemented. */
+    return CUBEB_ERROR_NOT_SUPPORTED;
+  }
+
   if (input_device || output_device) {
     /* Device selection not yet implemented. */
     return CUBEB_ERROR_DEVICE_UNAVAILABLE;
@@ -852,16 +845,19 @@
   r = snd_pcm_nonblock(stm->pcm, 1);
   assert(r == 0);
 
+  latency_us = latency_frames * 1e6 / stm->params.rate;
+
   /* Ugly hack: the PA ALSA plugin allows buffer configurations that can't
      possibly work.  See https://bugzilla.mozilla.org/show_bug.cgi?id=761274.
      Only resort to this hack if the handle_underrun workaround failed. */
   if (!ctx->local_config && ctx->is_pa) {
-    latency = latency < 500 ? 500 : latency;
+    const int min_latency = 5e5;
+    latency_us = latency_us < min_latency ? min_latency: latency_us;
   }
 
   r = snd_pcm_set_params(stm->pcm, format, SND_PCM_ACCESS_RW_INTERLEAVED,
                          stm->params.channels, stm->params.rate, 1,
-                         latency * 1000);
+                         latency_us);
   if (r < 0) {
     alsa_stream_destroy(stm);
     return CUBEB_ERROR_INVALID_FORMAT;
@@ -973,7 +969,7 @@
 
   /* get a pcm, disabling resampling, so we get a rate the
    * hardware/dmix/pulse/etc. supports. */
-  r = snd_pcm_open(&pcm, CUBEB_ALSA_PCM_NAME, SND_PCM_STREAM_PLAYBACK | SND_PCM_NO_AUTO_RESAMPLE, 0);
+  r = snd_pcm_open(&pcm, CUBEB_ALSA_PCM_NAME, SND_PCM_STREAM_PLAYBACK, SND_PCM_NO_AUTO_RESAMPLE);
   if (r < 0) {
     return CUBEB_ERROR;
   }
@@ -1006,11 +1002,11 @@
 }
 
 static int
-alsa_get_min_latency(cubeb * ctx, cubeb_stream_params params, uint32_t * latency_ms)
+alsa_get_min_latency(cubeb * ctx, cubeb_stream_params params, uint32_t * latency_frames)
 {
-  /* This is found to be an acceptable minimum, even on a super low-end
+  /* 40ms is found to be an acceptable minimum, even on a super low-end
    * machine. */
-  *latency_ms = 40;
+  *latency_frames = 40 * params.rate / 1000;
 
   return CUBEB_OK;
 }
diff -Naur cubeb-firefox/media/libcubeb/src/cubeb_audiotrack.c cubeb-upstream/media/libcubeb/src/cubeb_audiotrack.c
--- cubeb-firefox/media/libcubeb/src/cubeb_audiotrack.c	2016-07-31 15:20:25.000000000 +0500
+++ cubeb-upstream/media/libcubeb/src/cubeb_audiotrack.c	2016-08-03 04:39:35.698810270 +0500
@@ -250,9 +250,6 @@
     return CUBEB_ERROR;
   }
 
-  /* Convert to milliseconds. */
-  *latency_ms = *latency_ms * 1000 / params.rate;
-
   return CUBEB_OK;
 }
 
diff -Naur cubeb-firefox/media/libcubeb/src/cubeb_audiounit.cpp cubeb-upstream/media/libcubeb/src/cubeb_audiounit.cpp
--- cubeb-firefox/media/libcubeb/src/cubeb_audiounit.cpp	1970-01-01 05:00:00.000000000 +0500
+++ cubeb-upstream/media/libcubeb/src/cubeb_audiounit.cpp	2016-08-03 04:39:35.702810096 +0500
@@ -0,0 +1,2228 @@
+/*
+ * Copyright © 2011 Mozilla Foundation
+ *
+ * This program is made available under an ISC-style license.  See the
+ * accompanying file LICENSE for details.
+ */
+#undef NDEBUG
+
+#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_panner.h"
+#if !TARGET_OS_IPHONE
+#include "cubeb_osx_run_loop.h"
+#endif
+#include "cubeb_resampler.h"
+#include "cubeb_ring_array.h"
+#include "cubeb_utils.h"
+#include <algorithm>
+
+#if !defined(kCFCoreFoundationVersionNumber10_7)
+/* From CoreFoundation CFBase.h */
+#define kCFCoreFoundationVersionNumber10_7 635.00
+#endif
+
+#if !TARGET_OS_IPHONE && MAC_OS_X_VERSION_MIN_REQUIRED < 1060
+#define AudioComponent Component
+#define AudioComponentDescription ComponentDescription
+#define AudioComponentFindNext FindNextComponent
+#define AudioComponentInstanceNew OpenAComponent
+#define AudioComponentInstanceDispose CloseComponent
+#endif
+
+#if MAC_OS_X_VERSION_MIN_REQUIRED < 101000
+typedef UInt32  AudioFormatFlags;
+#endif
+
+#define CUBEB_STREAM_MAX 8
+
+#define AU_OUT_BUS    0
+#define AU_IN_BUS     1
+
+#if TARGET_OS_IPHONE
+#define CUBEB_AUDIOUNIT_SUBTYPE kAudioUnitSubType_RemoteIO
+#else
+#define CUBEB_AUDIOUNIT_SUBTYPE kAudioUnitSubType_HALOutput
+#endif
+
+//#define LOGGING_ENABLED
+#ifdef LOGGING_ENABLED
+#define LOG(...) do {                           \
+    fprintf(stderr, __VA_ARGS__);               \
+    fprintf(stderr, "(line: %d)\n", __LINE__);  \
+  } while(0)
+#else
+#define LOG(...)
+#endif
+
+#ifdef LOGGING_ENABLED
+#define PRINT_ERROR_CODE(str, r) do {                                \
+    fprintf(stderr, "Error %s (line: %d) (%d)\n", str, __LINE__, r); \
+  } while (0)
+#else
+#define PRINT_ERROR_CODE(str, r)
+#endif
+
+/* 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
+ * frames. */
+const uint32_t SAFE_MIN_LATENCY_FRAMES = 256;
+const uint32_t SAFE_MAX_LATENCY_FRAMES = 512;
+
+extern cubeb_ops const audiounit_ops;
+
+struct cubeb {
+  cubeb_ops const * ops;
+  owned_critical_section mutex;
+  int active_streams;
+  int limit_streams;
+  cubeb_device_collection_changed_callback collection_changed_callback;
+  void * collection_changed_user_ptr;
+  /* Differentiate input from output devices. */
+  cubeb_device_type collection_changed_devtype;
+  uint32_t devtype_device_count;
+  AudioObjectID * devtype_device_array;
+};
+
+class auto_array_wrapper
+{
+public:
+  explicit auto_array_wrapper(auto_array<float> * ar)
+  : float_ar(ar)
+  , short_ar(nullptr)
+  {assert((float_ar && !short_ar) || (!float_ar && short_ar));}
+
+  explicit auto_array_wrapper(auto_array<short> * ar)
+  : float_ar(nullptr)
+  , short_ar(ar)
+  {assert((float_ar && !short_ar) || (!float_ar && short_ar));}
+
+  ~auto_array_wrapper() {
+    assert((float_ar && !short_ar) || (!float_ar && short_ar));
+    delete float_ar;
+    delete short_ar;
+  }
+
+  void push(void * elements, size_t length){
+    assert((float_ar && !short_ar) || (!float_ar && short_ar));
+    if (float_ar)
+      return float_ar->push(static_cast<float*>(elements), length);
+    return short_ar->push(static_cast<short*>(elements), length);
+  }
+
+  size_t length() const {
+    assert((float_ar && !short_ar) || (!float_ar && short_ar));
+    if (float_ar)
+      return float_ar->length();
+    return short_ar->length();
+  }
+
+  void push_silence(size_t length) {
+    assert((float_ar && !short_ar) || (!float_ar && short_ar));
+    if (float_ar)
+      return float_ar->push_silence(length);
+    return short_ar->push_silence(length);
+  }
+
+  bool pop(void * elements, size_t length) {
+    assert((float_ar && !short_ar) || (!float_ar && short_ar));
+    if (float_ar)
+      return float_ar->pop(static_cast<float*>(elements), length);
+    return short_ar->pop(static_cast<short*>(elements), length);
+  }
+
+  void * data() const {
+    assert((float_ar && !short_ar) || (!float_ar && short_ar));
+    if (float_ar)
+      return float_ar->data();
+    return short_ar->data();
+  }
+
+private:
+  auto_array<float> * float_ar;
+  auto_array<short> * short_ar;
+};
+
+struct cubeb_stream {
+  cubeb * context;
+  cubeb_data_callback data_callback;
+  cubeb_state_callback state_callback;
+  cubeb_device_changed_callback device_changed_callback;
+  /* User pointer of data_callback */
+  void * user_ptr;
+  /* Format descriptions */
+  AudioStreamBasicDescription input_desc;
+  AudioStreamBasicDescription output_desc;
+  /* I/O AudioUnits */
+  AudioUnit input_unit;
+  AudioUnit output_unit;
+  /* Sample rate of input device*/
+  Float64 input_hw_rate;
+  owned_critical_section mutex;
+  /* Hold the input samples in every
+   * input callback iteration */
+  auto_array_wrapper * input_linear_buffer;
+  /* Frames on input buffer */
+  uint32_t input_buffer_frames;
+  /* Frame counters */
+  uint64_t frames_played;
+  uint64_t frames_queued;
+  uint64_t frames_read;
+  int shutdown;
+  int draining;
+  uint64_t current_latency_frames;
+  uint64_t hw_latency_frames;
+  float panning;
+  cubeb_resampler * resampler;
+};
+
+#if TARGET_OS_IPHONE
+typedef UInt32 AudioDeviceID;
+typedef UInt32 AudioObjectID;
+
+#define AudioGetCurrentHostTime mach_absolute_time
+
+uint64_t
+AudioConvertHostTimeToNanos(uint64_t host_time)
+{
+  static struct mach_timebase_info timebase_info;
+  static bool initialized = false;
+  if (!initialized) {
+    mach_timebase_info(&timebase_info);
+    initialized = true;
+  }
+
+  long double answer = host_time;
+  if (timebase_info.numer != timebase_info.denom) {
+    answer *= timebase_info.numer;
+    answer /= timebase_info.denom;
+  }
+  return (uint64_t)answer;
+}
+#endif
+
+static int64_t
+audiotimestamp_to_latency(AudioTimeStamp const * tstamp, cubeb_stream * stream)
+{
+  if (!(tstamp->mFlags & kAudioTimeStampHostTimeValid)) {
+    return 0;
+  }
+
+  uint64_t pres = AudioConvertHostTimeToNanos(tstamp->mHostTime);
+  uint64_t now = AudioConvertHostTimeToNanos(AudioGetCurrentHostTime());
+
+  return ((pres - now) * stream->output_desc.mSampleRate) / 1000000000LL;
+}
+
+static void
+audiounit_make_silent(AudioBuffer * ioData)
+{
+  memset(ioData->mData, 0, ioData->mDataByteSize);
+}
+
+static OSStatus
+audiounit_render_input(cubeb_stream * stm,
+                       AudioUnitRenderActionFlags * flags,
+                       AudioTimeStamp const * tstamp,
+                       UInt32 bus,
+                       UInt32 input_frames)
+{
+  /* Create the AudioBufferList to store input. */
+  AudioBufferList input_buffer_list;
+  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.mNumberBuffers = 1;
+
+  /* Render input samples */
+  OSStatus r = AudioUnitRender(stm->input_unit,
+                               flags,
+                               tstamp,
+                               bus,
+                               input_frames,
+                               &input_buffer_list);
+
+  if (r != noErr) {
+    PRINT_ERROR_CODE("AudioUnitRender", r);
+    audiounit_make_silent(&input_buffer_list.mBuffers[0]);
+    return r;
+  }
+
+  /* Copy input data in linear buffer. */
+  stm->input_linear_buffer->push(input_buffer_list.mBuffers[0].mData,
+                                 input_frames * stm->input_desc.mChannelsPerFrame);
+
+  LOG("- input:  buffers %d, size %d, channels %d, frames %d.",
+      input_buffer_list.mNumberBuffers,
+      input_buffer_list.mBuffers[0].mDataByteSize,
+      input_buffer_list.mBuffers[0].mNumberChannels,
+      input_frames);
+
+  /* Advance input frame counter. */
+  assert(input_frames > 0);
+  stm->frames_read += input_frames;
+
+  return noErr;
+}
+
+static OSStatus
+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);
+  long outframes, frames;
+
+  auto_lock lock(stm->mutex);
+
+  assert(stm->input_unit != NULL);
+  assert(AU_IN_BUS == bus);
+
+  if (stm->shutdown) {
+    LOG("- input shutdown");
+    return noErr;
+  }
+
+  OSStatus r = audiounit_render_input(stm, flags, tstamp, bus, input_frames);
+  if (r != noErr) {
+    return r;
+  }
+
+  // Full Duplex. We'll call data_callback in the AudioUnit output callback.
+  if (stm->output_unit != NULL) {
+    // User callback will be called by output callback
+    return noErr;
+  }
+
+  /* Input only. Call the user callback through resampler.
+     Resampler will deliver input buffer in the correct rate. */
+  frames = input_frames;
+  assert(input_frames <= stm->input_linear_buffer->length() / stm->input_desc.mChannelsPerFrame);
+  outframes = cubeb_resampler_fill(stm->resampler,
+                                   stm->input_linear_buffer->data(),
+                                   &frames,
+                                   NULL,
+                                   0);
+  // Reset input buffer
+  stm->input_linear_buffer->pop(nullptr, frames * stm->input_desc.mChannelsPerFrame);
+
+  if (outframes < 0 || outframes != input_frames) {
+    stm->shutdown = 1;
+    return noErr;
+  }
+
+  return noErr;
+}
+
+static OSStatus
+audiounit_output_callback(void * user_ptr,
+                          AudioUnitRenderActionFlags * flags,
+                          AudioTimeStamp const * tstamp,
+                          UInt32 bus,
+                          UInt32 output_frames,
+                          AudioBufferList * outBufferList)
+{
+  assert(AU_OUT_BUS == bus);
+  assert(outBufferList->mNumberBuffers == 1);
+
+  cubeb_stream * stm = static_cast<cubeb_stream *>(user_ptr);
+
+  LOG("- output(%p): buffers %d, size %d, channels %d, frames %d.", stm,
+      outBufferList->mNumberBuffers, outBufferList->mBuffers[0].mDataByteSize,
+      outBufferList->mBuffers[0].mNumberChannels, output_frames);
+
+  long outframes = 0, input_frames = 0;
+  void * output_buffer = NULL, * input_buffer = NULL;
+
+  auto_lock lock(stm->mutex);
+
+  if (stm->shutdown) {
+    LOG("- output shutdown.");
+    audiounit_make_silent(&outBufferList->mBuffers[0]);
+    return noErr;
+  }
+
+  stm->current_latency_frames = audiotimestamp_to_latency(tstamp, stm);
+  if (stm->draining) {
+    OSStatus r = AudioOutputUnitStop(stm->output_unit);
+    assert(r == 0);
+    if (stm->input_unit) {
+      r = AudioOutputUnitStop(stm->input_unit);
+      assert(r == 0);
+    }
+    stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_DRAINED);
+    audiounit_make_silent(&outBufferList->mBuffers[0]);
+    return noErr;
+  }
+  /* Get output buffer. */
+  output_buffer = outBufferList->mBuffers[0].mData;
+  /* If Full duplex get also input buffer */
+  if (stm->input_unit != NULL) {
+    /* Output callback came first */
+    if (stm->frames_read == 0) {
+      LOG("Output callback came first send silent.");
+      stm->input_linear_buffer->push_silence(stm->input_buffer_frames *
+                                            stm->input_desc.mChannelsPerFrame);
+    }
+    /* Input samples stored previously in input callback. */
+    if (stm->input_linear_buffer->length() == 0) {
+      /* Do nothing, there should be enough pre-buffered data to consume. */
+      LOG("Input hole. Requested more input than ouput.");
+    }
+    // The input buffer
+    input_buffer = stm->input_linear_buffer->data();
+    // Number of input frames in the buffer
+    input_frames = stm->input_linear_buffer->length() / stm->input_desc.mChannelsPerFrame;
+  }
+
+  /* Call user callback through resampler. */
+  outframes = cubeb_resampler_fill(stm->resampler,
+                                   input_buffer,
+                                   input_buffer ? &input_frames : NULL,
+                                   output_buffer,
+                                   output_frames);
+
+  if (input_buffer) {
+    stm->input_linear_buffer->pop(nullptr, input_frames * stm->input_desc.mChannelsPerFrame);
+  }
+
+  if (outframes < 0) {
+    stm->shutdown = 1;
+    return noErr;
+  }
+
+  size_t outbpf = stm->output_desc.mBytesPerFrame;
+  stm->draining = outframes < output_frames;
+  stm->frames_played = stm->frames_queued;
+  stm->frames_queued += outframes;
+
+  AudioFormatFlags outaff = stm->output_desc.mFormatFlags;
+  float panning = (stm->output_desc.mChannelsPerFrame == 2) ? stm->panning : 0.0f;
+
+  /* Post process output samples. */
+  if (stm->draining) {
+    /* Clear missing frames (silence) */
+    memset((uint8_t*)output_buffer + outframes * outbpf, 0, (output_frames - outframes) * outbpf);
+  }
+  /* Pan stereo. */
+  if (panning != 0.0f) {
+    if (outaff & kAudioFormatFlagIsFloat) {
+      cubeb_pan_stereo_buffer_float((float*)output_buffer, outframes, panning);
+    } else if (outaff & kAudioFormatFlagIsSignedInteger) {
+      cubeb_pan_stereo_buffer_int((short*)output_buffer, outframes, panning);
+    }
+  }
+  return noErr;
+}
+
+extern "C" {
+int
+audiounit_init(cubeb ** context, char const * context_name)
+{
+  cubeb * ctx;
+
+  *context = NULL;
+
+  ctx = new cubeb;
+  assert(ctx);
+  PodZero(ctx, 1);
+
+  ctx->ops = &audiounit_ops;
+
+  ctx->mutex = owned_critical_section();
+
+  ctx->active_streams = 0;
+
+  ctx->limit_streams = kCFCoreFoundationVersionNumber < kCFCoreFoundationVersionNumber10_7;
+#if !TARGET_OS_IPHONE
+  cubeb_set_coreaudio_notification_runloop();
+#endif
+
+  *context = ctx;
+
+  return CUBEB_OK;
+}
+}
+
+static char const *
+audiounit_get_backend_id(cubeb * ctx)
+{
+  return "audiounit";
+}
+
+#if !TARGET_OS_IPHONE
+static int
+audiounit_get_output_device_id(AudioDeviceID * device_id)
+{
+  UInt32 size;
+  OSStatus r;
+  AudioObjectPropertyAddress output_device_address = {
+    kAudioHardwarePropertyDefaultOutputDevice,
+    kAudioObjectPropertyScopeGlobal,
+    kAudioObjectPropertyElementMaster
+  };
+
+  size = sizeof(*device_id);
+
+  r = AudioObjectGetPropertyData(kAudioObjectSystemObject,
+                                 &output_device_address,
+                                 0,
+                                 NULL,
+                                 &size,
+                                 device_id);
+  if (r != noErr) {
+    PRINT_ERROR_CODE("output_device_id", r);
+    return CUBEB_ERROR;
+  }
+
+  return CUBEB_OK;
+}
+
+static int
+audiounit_get_input_device_id(AudioDeviceID * device_id)
+{
+  UInt32 size;
+  OSStatus r;
+  AudioObjectPropertyAddress input_device_address = {
+    kAudioHardwarePropertyDefaultInputDevice,
+    kAudioObjectPropertyScopeGlobal,
+    kAudioObjectPropertyElementMaster
+  };
+
+  size = sizeof(*device_id);
+
+  r = AudioObjectGetPropertyData(kAudioObjectSystemObject,
+                                 &input_device_address,
+                                 0,
+                                 NULL,
+                                 &size,
+                                 device_id);
+  if (r != noErr) {
+    return CUBEB_ERROR;
+  }
+
+  return CUBEB_OK;
+}
+
+static OSStatus
+audiounit_property_listener_callback(AudioObjectID id, UInt32 address_count,
+                                     const AudioObjectPropertyAddress * addresses,
+                                     void * user)
+{
+  cubeb_stream * stm = (cubeb_stream*) user;
+
+  for (UInt32 i = 0; i < address_count; i++) {
+    switch(addresses[i].mSelector) {
+    case kAudioHardwarePropertyDefaultOutputDevice:
+    case kAudioHardwarePropertyDefaultInputDevice:
+      /* fall through */
+    case kAudioDevicePropertyDataSource: {
+        auto_lock lock(stm->mutex);
+        if (stm->device_changed_callback) {
+          stm->device_changed_callback(stm->user_ptr);
+        }
+        break;
+      }
+    }
+  }
+
+  return noErr;
+}
+
+OSStatus
+audiounit_add_listener(cubeb_stream * stm, AudioDeviceID id, AudioObjectPropertySelector selector,
+    AudioObjectPropertyScope scope, AudioObjectPropertyListenerProc listener)
+{
+  AudioObjectPropertyAddress address = {
+      selector,
+      scope,
+      kAudioObjectPropertyElementMaster
+  };
+
+  return AudioObjectAddPropertyListener(id, &address, listener, stm);
+}
+
+OSStatus
+audiounit_remove_listener(cubeb_stream * stm, AudioDeviceID id,
+                          AudioObjectPropertySelector selector,
+                          AudioObjectPropertyScope scope,
+                          AudioObjectPropertyListenerProc listener)
+{
+  AudioObjectPropertyAddress address = {
+      selector,
+      scope,
+      kAudioObjectPropertyElementMaster
+  };
+
+  return AudioObjectRemovePropertyListener(id, &address, listener, stm);
+}
+
+static int
+audiounit_install_device_changed_callback(cubeb_stream * stm)
+{
+  OSStatus r;
+
+  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. */
+    AudioDeviceID output_dev_id;
+    r = audiounit_get_output_device_id(&output_dev_id);
+    if (r != noErr) {
+      return CUBEB_ERROR;
+    }
+
+    r = audiounit_add_listener(stm, output_dev_id, kAudioDevicePropertyDataSource,
+        kAudioDevicePropertyScopeOutput, &audiounit_property_listener_callback);
+    if (r != noErr) {
+      return CUBEB_ERROR;
+    }
+
+    /* 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
+     * dropdown list. */
+    r = audiounit_add_listener(stm, kAudioObjectSystemObject, kAudioHardwarePropertyDefaultOutputDevice,
+        kAudioObjectPropertyScopeGlobal, &audiounit_property_listener_callback);
+    if (r != noErr) {
+      return CUBEB_ERROR;
+    }
+  }
+
+  if (stm->input_unit) {
+    /* This event will notify us when the data source on the input device changes. */
+    AudioDeviceID input_dev_id;
+    r = audiounit_get_input_device_id(&input_dev_id);
+    if (r != noErr) {
+      return CUBEB_ERROR;
+    }
+
+    r = audiounit_add_listener(stm, input_dev_id, kAudioDevicePropertyDataSource,
+        kAudioDevicePropertyScopeInput, &audiounit_property_listener_callback);
+    if (r != noErr) {
+      return CUBEB_ERROR;
+    }
+
+    /* This event will notify us when the default input device changes. */
+    r = audiounit_add_listener(stm, kAudioObjectSystemObject, kAudioHardwarePropertyDefaultInputDevice,
+        kAudioObjectPropertyScopeGlobal, &audiounit_property_listener_callback);
+    if (r != noErr) {
+      return CUBEB_ERROR;
+    }
+  }
+
+  return CUBEB_OK;
+}
+
+static int
+audiounit_uninstall_device_changed_callback(cubeb_stream * stm)
+{
+  OSStatus r;
+
+  if (stm->output_unit) {
+    AudioDeviceID output_dev_id;
+    r = audiounit_get_output_device_id(&output_dev_id);
+    if (r != noErr) {
+      return CUBEB_ERROR;
+    }
+
+    r = audiounit_remove_listener(stm, output_dev_id, kAudioDevicePropertyDataSource,
+        kAudioDevicePropertyScopeOutput, &audiounit_property_listener_callback);
+    if (r != noErr) {
+      return CUBEB_ERROR;
+    }
+
+    r = audiounit_remove_listener(stm, kAudioObjectSystemObject, kAudioHardwarePropertyDefaultOutputDevice,
+        kAudioObjectPropertyScopeGlobal, &audiounit_property_listener_callback);
+    if (r != noErr) {
+      return CUBEB_ERROR;
+    }
+  }
+
+  if (stm->input_unit) {
+    AudioDeviceID input_dev_id;
+    r = audiounit_get_input_device_id(&input_dev_id);
+    if (r != noErr) {
+      return CUBEB_ERROR;
+    }
+
+    r = audiounit_remove_listener(stm, input_dev_id, kAudioDevicePropertyDataSource,
+        kAudioDevicePropertyScopeInput, &audiounit_property_listener_callback);
+    if (r != noErr) {
+      return CUBEB_ERROR;
+    }
+
+    r = audiounit_remove_listener(stm, kAudioObjectSystemObject, kAudioHardwarePropertyDefaultInputDevice,
+        kAudioObjectPropertyScopeGlobal, &audiounit_property_listener_callback);
+    if (r != noErr) {
+      return CUBEB_ERROR;
+    }
+  }
+  return CUBEB_OK;
+}
+
+/* Get the acceptable buffer size (in frames) that this device can work with. */
+static int
+audiounit_get_acceptable_latency_range(AudioValueRange * latency_range)
+{
+  UInt32 size;
+  OSStatus r;
+  AudioDeviceID output_device_id;
+  AudioObjectPropertyAddress output_device_buffer_size_range = {
+    kAudioDevicePropertyBufferFrameSizeRange,
+    kAudioDevicePropertyScopeOutput,
+    kAudioObjectPropertyElementMaster
+  };
+
+  if (audiounit_get_output_device_id(&output_device_id) != CUBEB_OK) {
+    LOG("Could not get default output device id.");
+    return CUBEB_ERROR;
+  }
+
+  /* Get the buffer size range this device supports */
+  size = sizeof(*latency_range);
+
+  r = AudioObjectGetPropertyData(output_device_id,
+                                 &output_device_buffer_size_range,
+                                 0,
+                                 NULL,
+                                 &size,
+                                 latency_range);
+  if (r != noErr) {
+    PRINT_ERROR_CODE("AudioObjectGetPropertyData/buffer size range", r);
+    return CUBEB_ERROR;
+  }
+
+  return CUBEB_OK;
+}
+#endif /* !TARGET_OS_IPHONE */
+
+static AudioObjectID
+audiounit_get_default_device_id(cubeb_device_type type)
+{
+  AudioObjectPropertyAddress adr = { 0, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };
+  AudioDeviceID devid;
+  UInt32 size;
+
+  if (type == CUBEB_DEVICE_TYPE_OUTPUT) {
+    adr.mSelector = kAudioHardwarePropertyDefaultOutputDevice;
+  } else if (type == CUBEB_DEVICE_TYPE_INPUT) {
+    adr.mSelector = kAudioHardwarePropertyDefaultInputDevice;
+  } else {
+    return kAudioObjectUnknown;
+  }
+
+  size = sizeof(AudioDeviceID);
+  if (AudioObjectGetPropertyData(kAudioObjectSystemObject, &adr, 0, NULL, &size, &devid) != noErr) {
+    return kAudioObjectUnknown;
+  }
+
+  return devid;
+}
+
+int
+audiounit_get_max_channel_count(cubeb * ctx, uint32_t * max_channels)
+{
+#if TARGET_OS_IPHONE
+  //TODO: [[AVAudioSession sharedInstance] maximumOutputNumberOfChannels]
+  *max_channels = 2;
+#else
+  UInt32 size;
+  OSStatus r;
+  AudioDeviceID output_device_id;
+  AudioStreamBasicDescription stream_format;
+  AudioObjectPropertyAddress stream_format_address = {
+    kAudioDevicePropertyStreamFormat,
+    kAudioDevicePropertyScopeOutput,
+    kAudioObjectPropertyElementMaster
+  };
+
+  assert(ctx && max_channels);
+
+  if (audiounit_get_output_device_id(&output_device_id) != CUBEB_OK) {
+    return CUBEB_ERROR;
+  }
+
+  size = sizeof(stream_format);
+
+  r = AudioObjectGetPropertyData(output_device_id,
+                                 &stream_format_address,
+                                 0,
+                                 NULL,
+                                 &size,
+                                 &stream_format);
+  if (r != noErr) {
+    PRINT_ERROR_CODE("AudioObjectPropertyAddress/StreamFormat", r);
+    return CUBEB_ERROR;
+  }
+
+  *max_channels = stream_format.mChannelsPerFrame;
+#endif
+  return CUBEB_OK;
+}
+
+static int
+audiounit_get_min_latency(cubeb * ctx, cubeb_stream_params params, uint32_t * latency_frames)
+{
+#if TARGET_OS_IPHONE
+  //TODO: [[AVAudioSession sharedInstance] inputLatency]
+  return CUBEB_ERROR_NOT_SUPPORTED;
+#else
+  AudioValueRange latency_range;
+  if (audiounit_get_acceptable_latency_range(&latency_range) != CUBEB_OK) {
+    LOG("Could not get acceptable latency range.");
+    return CUBEB_ERROR;
+  }
+
+  *latency_frames = std::max<uint32_t>(latency_range.mMinimum,
+                                       SAFE_MIN_LATENCY_FRAMES);
+#endif
+
+  return CUBEB_OK;
+}
+
+static int
+audiounit_get_preferred_sample_rate(cubeb * ctx, uint32_t * rate)
+{
+#if TARGET_OS_IPHONE
+  //TODO
+  return CUBEB_ERROR_NOT_SUPPORTED;
+#else
+  UInt32 size;
+  OSStatus r;
+  Float64 fsamplerate;
+  AudioDeviceID output_device_id;
+  AudioObjectPropertyAddress samplerate_address = {
+    kAudioDevicePropertyNominalSampleRate,
+    kAudioObjectPropertyScopeGlobal,
+    kAudioObjectPropertyElementMaster
+  };
+
+  if (audiounit_get_output_device_id(&output_device_id) != CUBEB_OK) {
+    return CUBEB_ERROR;
+  }
+
+  size = sizeof(fsamplerate);
+  r = AudioObjectGetPropertyData(output_device_id,
+                                 &samplerate_address,
+                                 0,
+                                 NULL,
+                                 &size,
+                                 &fsamplerate);
+
+  if (r != noErr) {
+    return CUBEB_ERROR;
+  }
+
+  *rate = static_cast<uint32_t>(fsamplerate);
+#endif
+  return CUBEB_OK;
+}
+
+static OSStatus audiounit_remove_device_listener(cubeb * context);
+
+static void
+audiounit_destroy(cubeb * ctx)
+{
+  // Disabling this assert for bug 1083664 -- we seem to leak a stream
+  // assert(ctx->active_streams == 0);
+
+  /* Unregister the callback if necessary. */
+  if(ctx->collection_changed_callback) {
+    auto_lock lock(ctx->mutex);
+    audiounit_remove_device_listener(ctx);
+  }
+
+  delete ctx;
+}
+
+static void audiounit_stream_destroy(cubeb_stream * stm);
+
+static int
+audio_stream_desc_init(AudioStreamBasicDescription * ss,
+                       const cubeb_stream_params * stream_params)
+{
+  switch (stream_params->format) {
+  case CUBEB_SAMPLE_S16LE:
+    ss->mBitsPerChannel = 16;
+    ss->mFormatFlags = kAudioFormatFlagIsSignedInteger;
+    break;
+  case CUBEB_SAMPLE_S16BE:
+    ss->mBitsPerChannel = 16;
+    ss->mFormatFlags = kAudioFormatFlagIsSignedInteger |
+      kAudioFormatFlagIsBigEndian;
+    break;
+  case CUBEB_SAMPLE_FLOAT32LE:
+    ss->mBitsPerChannel = 32;
+    ss->mFormatFlags = kAudioFormatFlagIsFloat;
+    break;
+  case CUBEB_SAMPLE_FLOAT32BE:
+    ss->mBitsPerChannel = 32;
+    ss->mFormatFlags = kAudioFormatFlagIsFloat |
+      kAudioFormatFlagIsBigEndian;
+    break;
+  default:
+    return CUBEB_ERROR_INVALID_FORMAT;
+  }
+
+  ss->mFormatID = kAudioFormatLinearPCM;
+  ss->mFormatFlags |= kLinearPCMFormatFlagIsPacked;
+  ss->mSampleRate = stream_params->rate;
+  ss->mChannelsPerFrame = stream_params->channels;
+
+  ss->mBytesPerFrame = (ss->mBitsPerChannel / 8) * ss->mChannelsPerFrame;
+  ss->mFramesPerPacket = 1;
+  ss->mBytesPerPacket = ss->mBytesPerFrame * ss->mFramesPerPacket;
+
+  ss->mReserved = 0;
+
+  return CUBEB_OK;
+}
+
+static int
+audiounit_create_unit(AudioUnit * unit,
+                      bool is_input,
+                      const cubeb_stream_params * stream_params,
+                      cubeb_devid device)
+{
+  AudioComponentDescription desc;
+  AudioComponent comp;
+  UInt32 enable;
+  AudioDeviceID devid;
+  OSStatus rv;
+
+  desc.componentType = kAudioUnitType_Output;
+  desc.componentSubType = CUBEB_AUDIOUNIT_SUBTYPE;
+  desc.componentManufacturer = kAudioUnitManufacturer_Apple;
+  desc.componentFlags = 0;
+  desc.componentFlagsMask = 0;
+  comp = AudioComponentFindNext(NULL, &desc);
+  if (comp == NULL) {
+    LOG("Could not find matching audio hardware.");
+    return CUBEB_ERROR;
+  }
+
+  rv = AudioComponentInstanceNew(comp, unit);
+  if (rv != noErr) {
+    PRINT_ERROR_CODE("AudioComponentInstanceNew", rv);
+    return CUBEB_ERROR;
+  }
+
+  enable = 1;
+  rv = AudioUnitSetProperty(*unit, kAudioOutputUnitProperty_EnableIO,
+           is_input ? kAudioUnitScope_Input : kAudioUnitScope_Output,
+           is_input ? AU_IN_BUS : AU_OUT_BUS, &enable, sizeof(UInt32));
+  if (rv != noErr) {
+    PRINT_ERROR_CODE("AudioUnitSetProperty/kAudioOutputUnitProperty_EnableIO", rv);
+    return CUBEB_ERROR;
+  }
+
+  enable = 0;
+  rv = AudioUnitSetProperty(*unit, kAudioOutputUnitProperty_EnableIO,
+            is_input ? kAudioUnitScope_Output : kAudioUnitScope_Input,
+            is_input ? AU_OUT_BUS : AU_IN_BUS, &enable, sizeof(UInt32));
+  if (rv != noErr) {
+    PRINT_ERROR_CODE("AudioUnitSetProperty/kAudioOutputUnitProperty_EnableIO", rv);
+    return CUBEB_ERROR;
+  }
+
+  if (device == NULL) {
+    devid = audiounit_get_default_device_id(is_input ? CUBEB_DEVICE_TYPE_INPUT
+                                                     : CUBEB_DEVICE_TYPE_OUTPUT);
+  } else {
+    devid = reinterpret_cast<intptr_t>(device);
+  }
+  int err = AudioUnitSetProperty(*unit, kAudioOutputUnitProperty_CurrentDevice,
+                                 kAudioUnitScope_Global,
+                                 is_input ? AU_IN_BUS : AU_OUT_BUS,
+                                 &devid, sizeof(AudioDeviceID));
+  if (err != noErr) {
+    PRINT_ERROR_CODE("AudioUnitSetProperty/kAudioOutputUnitProperty_CurrentDevice", rv);
+    return CUBEB_ERROR;
+  }
+
+  return CUBEB_OK;
+}
+
+static int
+audiounit_init_input_linear_buffer(cubeb_stream * stream, uint32_t capacity)
+{
+  if (stream->input_desc.mFormatFlags == kAudioFormatFlagIsSignedInteger) {
+    stream->input_linear_buffer = new auto_array_wrapper(
+        new auto_array<short>(capacity *
+                              stream->input_buffer_frames *
+                              stream->input_desc.mChannelsPerFrame) );
+  } else {
+    stream->input_linear_buffer = new auto_array_wrapper(
+        new auto_array<float>(capacity *
+                              stream->input_buffer_frames *
+                              stream->input_desc.mChannelsPerFrame) );
+  }
+
+  if (!stream->input_linear_buffer) {
+    return CUBEB_ERROR;
+  }
+
+  assert(stream->input_linear_buffer->length() == 0);
+
+  // Pre-buffer silence if needed
+  if (capacity != 1) {
+    size_t silence_size = stream->input_buffer_frames *
+                          stream->input_desc.mChannelsPerFrame;
+    stream->input_linear_buffer->push_silence(silence_size);
+
+    assert(stream->input_linear_buffer->length() == silence_size);
+  }
+
+  return CUBEB_OK;
+}
+
+static void
+audiounit_destroy_input_linear_buffer(cubeb_stream * stream)
+{
+  delete stream->input_linear_buffer;
+}
+
+static uint32_t
+audiounit_clamp_latency(cubeb_stream * stm,
+                              uint32_t latency_frames)
+{
+  // For the 1st stream set anything within safe min-max
+  assert(stm->context->active_streams > 0);
+  if (stm->context->active_streams == 1) {
+    return std::max(std::min<uint32_t>(latency_frames, SAFE_MAX_LATENCY_FRAMES),
+                    SAFE_MIN_LATENCY_FRAMES);
+  }
+
+  // If more than one stream operates in parallel
+  // allow only lower values of latency
+  int r;
+  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);
+    if (r != noErr) {
+      PRINT_ERROR_CODE("AudioUnitGetProperty/output/kAudioDevicePropertyBufferFrameSize", r);
+      return 0;
+    }
+
+    output_buffer_size = std::max(std::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);
+    if (r != noErr) {
+      PRINT_ERROR_CODE("AudioUnitGetProperty/input/kAudioDevicePropertyBufferFrameSize", r);
+      return 0;
+    }
+
+    input_buffer_size = std::max(std::min<uint32_t>(input_buffer_size, SAFE_MAX_LATENCY_FRAMES),
+                                 SAFE_MIN_LATENCY_FRAMES);
+  }
+
+  // Every following active streams can only set smaller latency
+  UInt32 upper_latency_limit = 0;
+  if (input_buffer_size != 0 && output_buffer_size != 0) {
+    upper_latency_limit = std::min<uint32_t>(input_buffer_size, output_buffer_size);
+  } else if (input_buffer_size != 0) {
+    upper_latency_limit = input_buffer_size;
+  } else if (output_buffer_size != 0) {
+    upper_latency_limit = output_buffer_size;
+  } else {
+    upper_latency_limit = SAFE_MAX_LATENCY_FRAMES;
+  }
+
+  return std::max(std::min<uint32_t>(latency_frames, upper_latency_limit),
+                  SAFE_MIN_LATENCY_FRAMES);
+}
+
+static int
+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_stream * stm;
+  AudioUnit input_unit;
+  AudioUnit output_unit;
+  int r;
+  AURenderCallbackStruct aurcbs_in;
+  AURenderCallbackStruct aurcbs_out;
+  UInt32 size;
+
+  assert(context);
+  *stream = NULL;
+
+  {
+    auto_lock lock(context->mutex);
+    if (context->limit_streams && context->active_streams >= CUBEB_STREAM_MAX) {
+      LOG("Reached the stream limit of %d", CUBEB_STREAM_MAX);
+      return CUBEB_ERROR;
+    }
+    context->active_streams += 1;
+  }
+
+  if (input_stream_params != NULL) {
+    r = audiounit_create_unit(&input_unit, true,
+                              input_stream_params,
+                              input_device);
+    if (r != CUBEB_OK) {
+      LOG("AudioUnit creation for input failed.");
+      return r;
+    }
+  }
+
+  if (output_stream_params != NULL) {
+    r = audiounit_create_unit(&output_unit, false,
+                              output_stream_params,
+                              output_device);
+    if (r != CUBEB_OK) {
+      LOG("AudioUnit creation for output failed.");
+      return r;
+    }
+  }
+
+  stm = new cubeb_stream;
+  assert(stm);
+  PodZero(stm, 1);
+
+  /* These could be different in the future if we have both
+   * full-duplex stream and different devices for input vs output. */
+  stm->input_unit  = (input_stream_params != NULL) ? input_unit : NULL;
+  stm->output_unit = (output_stream_params != NULL) ? output_unit : NULL;
+  stm->context = context;
+  stm->data_callback = data_callback;
+  stm->state_callback = state_callback;
+  stm->user_ptr = user_ptr;
+  stm->device_changed_callback = NULL;
+  stm->mutex = owned_critical_section();
+
+  /* Init data members where necessary */
+  stm->hw_latency_frames = UINT64_MAX;
+
+  /* Silently clamp the latency down to the platform default, because we
+   * synthetize the clock from the callbacks, and we want the clock to update
+   * often. */
+  latency_frames = audiounit_clamp_latency(stm, latency_frames);
+  assert(latency_frames > 0);
+
+  /* Setup Input Stream! */
+  if (input_stream_params != NULL) {
+    /* 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,
+                            &size);
+    if (r != noErr) {
+      PRINT_ERROR_CODE("AudioUnitGetProperty/input/kAudioUnitProperty_StreamFormat", r);
+      audiounit_stream_destroy(stm);
+      return CUBEB_ERROR;
+    }
+    stm->input_hw_rate = input_hw_desc.mSampleRate;
+
+    /* Set format description according to the input params. */
+    r = audio_stream_desc_init(&stm->input_desc, input_stream_params);
+    if (r != CUBEB_OK) {
+      LOG("Setting format description for input failed.");
+      audiounit_stream_destroy(stm);
+      return r;
+    }
+
+    // Use latency to set buffer size
+    stm->input_buffer_frames = latency_frames;
+    LOG("Input buffer frame count %u.", stm->input_buffer_frames);
+    r = AudioUnitSetProperty(stm->input_unit,
+                             kAudioDevicePropertyBufferFrameSize,
+                             kAudioUnitScope_Output,
+                             AU_IN_BUS,
+                             &stm->input_buffer_frames,
+                             sizeof(UInt32));
+    if (r != noErr) {
+      PRINT_ERROR_CODE("AudioUnitSetProperty/input/kAudioDevicePropertyBufferFrameSize", r);
+      audiounit_stream_destroy(stm);
+      return CUBEB_ERROR;
+    }
+
+    AudioStreamBasicDescription src_desc = stm->input_desc;
+    /* Input AudioUnit must be configured with device's sample rate.
+       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,
+                             sizeof(AudioStreamBasicDescription));
+    if (r != noErr) {
+      PRINT_ERROR_CODE("AudioUnitSetProperty/input/kAudioUnitProperty_StreamFormat", r);
+      audiounit_stream_destroy(stm);
+      return CUBEB_ERROR;
+    }
+
+    /* Frames per buffer in the input callback. */
+    r = AudioUnitSetProperty(stm->input_unit,
+                             kAudioUnitProperty_MaximumFramesPerSlice,
+                             kAudioUnitScope_Output,
+                             AU_IN_BUS,
+                             &stm->input_buffer_frames,
+                             sizeof(UInt32));
+    if (r != noErr) {
+      PRINT_ERROR_CODE("AudioUnitSetProperty/input/kAudioUnitProperty_MaximumFramesPerSlice", r);
+      audiounit_stream_destroy(stm);
+      return CUBEB_ERROR;
+    }
+
+    // Input only capacity
+    unsigned int array_capacity = 1;
+    if (output_stream_params) {
+      // Full-duplex increase capacity
+      array_capacity = 8;
+    }
+    if (audiounit_init_input_linear_buffer(stm, array_capacity) != CUBEB_OK) {
+      audiounit_stream_destroy(stm);
+      return CUBEB_ERROR;
+    }
+
+    assert(stm->input_unit != NULL);
+    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));
+    if (r != noErr) {
+      PRINT_ERROR_CODE("AudioUnitSetProperty/input/kAudioOutputUnitProperty_SetInputCallback", r);
+      audiounit_stream_destroy(stm);
+      return CUBEB_ERROR;
+    }
+    LOG("Input audiounit init successfully.");
+  }
+
+  /* Setup Output Stream! */
+  if (output_stream_params != NULL) {
+    r = audio_stream_desc_init(&stm->output_desc, output_stream_params);
+    if (r != CUBEB_OK) {
+      LOG("Could not initialize the audio stream description.");
+      audiounit_stream_destroy(stm);
+      return r;
+    }
+
+    /* Get output device sample rate. */
+    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,
+                             &size);
+    if (r != noErr) {
+      PRINT_ERROR_CODE("AudioUnitGetProperty/output/tkAudioUnitProperty_StreamFormat", r);
+      audiounit_stream_destroy(stm);
+      return CUBEB_ERROR;
+    }
+
+    r = AudioUnitSetProperty(stm->output_unit,
+                             kAudioUnitProperty_StreamFormat,
+                             kAudioUnitScope_Input,
+                             AU_OUT_BUS,
+                             &stm->output_desc,
+                             sizeof(AudioStreamBasicDescription));
+    if (r != noErr) {
+      PRINT_ERROR_CODE("AudioUnitSetProperty/output/kAudioUnitProperty_StreamFormat", r);
+      audiounit_stream_destroy(stm);
+      return CUBEB_ERROR;
+    }
+
+    // Use latency to calculate buffer size
+    uint32_t output_buffer_frames = latency_frames;
+    LOG("Output buffer frame count %u.", output_buffer_frames);
+    r = AudioUnitSetProperty(stm->output_unit,
+                             kAudioDevicePropertyBufferFrameSize,
+                             kAudioUnitScope_Input,
+                             AU_OUT_BUS,
+                             &output_buffer_frames,
+                             sizeof(output_buffer_frames));
+    if (r != noErr) {
+      PRINT_ERROR_CODE("AudioUnitSetProperty/output/kAudioDevicePropertyBufferFrameSize", r);
+      audiounit_stream_destroy(stm);
+      return CUBEB_ERROR;
+    }
+
+    assert(stm->output_unit != NULL);
+    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));
+    if (r != noErr) {
+      audiounit_stream_destroy(stm);
+      PRINT_ERROR_CODE("AudioUnitSetProperty/output/kAudioUnitProperty_SetRenderCallback", r);
+      return CUBEB_ERROR;
+    }
+    LOG("Output audiounit init successfully.");
+  }
+
+  // Setting the latency doesn't work well for USB headsets (eg. plantronics).
+  // Keep the default latency for now.
+#if 0
+  buffer_size = latency;
+
+  /* Get the range of latency this particular device can work with, and clamp
+   * the requested latency to this acceptable range. */
+#if !TARGET_OS_IPHONE
+  if (audiounit_get_acceptable_latency_range(&latency_range) != CUBEB_OK) {
+    audiounit_stream_destroy(stm);
+    return CUBEB_ERROR;
+  }
+
+  if (buffer_size < (unsigned int) latency_range.mMinimum) {
+    buffer_size = (unsigned int) latency_range.mMinimum;
+  } else if (buffer_size > (unsigned int) latency_range.mMaximum) {
+    buffer_size = (unsigned int) latency_range.mMaximum;
+  }
+
+  /**
+   * Get the default buffer size. If our latency request is below the default,
+   * set it. Otherwise, use the default latency.
+   **/
+  size = sizeof(default_buffer_size);
+  if (AudioUnitGetProperty(stm->output_unit, kAudioDevicePropertyBufferFrameSize,
+        kAudioUnitScope_Output, 0, &default_buffer_size, &size) != 0) {
+    audiounit_stream_destroy(stm);
+    return CUBEB_ERROR;
+  }
+
+  if (buffer_size < default_buffer_size) {
+    /* Set the maximum number of frame that the render callback will ask for,
+     * effectively setting the latency of the stream. This is process-wide. */
+    if (AudioUnitSetProperty(stm->output_unit, kAudioDevicePropertyBufferFrameSize,
+          kAudioUnitScope_Output, 0, &buffer_size, sizeof(buffer_size)) != 0) {
+      audiounit_stream_destroy(stm);
+      return CUBEB_ERROR;
+    }
+  }
+#else  // TARGET_OS_IPHONE
+  //TODO: [[AVAudioSession sharedInstance] inputLatency]
+  // http://stackoverflow.com/questions/13157523/kaudiodevicepropertybufferframesize-replacement-for-ios
+#endif
+#endif
+
+  /* We use a resampler because input AudioUnit operates
+   * reliable only in the capture device sample rate.
+   * Resampler will convert it to the user sample rate
+   * and deliver it to the callback. */
+  uint32_t target_sample_rate;
+  if (input_stream_params) {
+    target_sample_rate = input_stream_params->rate;
+  } else {
+    assert(output_stream_params);
+    target_sample_rate = output_stream_params->rate;
+  }
+
+  cubeb_stream_params input_unconverted_params;
+  if (input_stream_params) {
+    input_unconverted_params = *input_stream_params;
+    /* Use the rate of the input device. */
+    input_unconverted_params.rate = stm->input_hw_rate;
+  }
+
+  /* Create resampler. Output params are unchanged
+   * because we do not need conversion on the output. */
+  stm->resampler = cubeb_resampler_create(stm,
+                                          input_stream_params ? &input_unconverted_params : NULL,
+                                          output_stream_params,
+                                          target_sample_rate,
+                                          stm->data_callback,
+                                          stm->user_ptr,
+                                          CUBEB_RESAMPLER_QUALITY_DESKTOP);
+  if (!stm->resampler) {
+    LOG("Could not create resampler.");
+    audiounit_stream_destroy(stm);
+    return CUBEB_ERROR;
+  }
+
+  if (stm->input_unit != NULL) {
+    r = AudioUnitInitialize(stm->input_unit);
+    if (r != noErr) {
+      PRINT_ERROR_CODE("AudioUnitInitialize/input", r);
+      audiounit_stream_destroy(stm);
+      return CUBEB_ERROR;
+    }
+  }
+
+  if (stm->output_unit != NULL) {
+    r = AudioUnitInitialize(stm->output_unit);
+    if (r != noErr) {
+      PRINT_ERROR_CODE("AudioUnitInitialize/output", r);
+      audiounit_stream_destroy(stm);
+      return CUBEB_ERROR;
+    }
+  }
+
+  *stream = stm;
+  LOG("Cubeb stream (%p) init successful.", stm);
+  return CUBEB_OK;
+}
+
+static void
+audiounit_stream_destroy(cubeb_stream * stm)
+{
+  stm->shutdown = 1;
+
+  if (stm->input_unit != NULL) {
+    AudioOutputUnitStop(stm->input_unit);
+    AudioUnitUninitialize(stm->input_unit);
+    AudioComponentInstanceDispose(stm->input_unit);
+  }
+
+  audiounit_destroy_input_linear_buffer(stm);
+
+  if (stm->output_unit != NULL) {
+    AudioOutputUnitStop(stm->output_unit);
+    AudioUnitUninitialize(stm->output_unit);
+    AudioComponentInstanceDispose(stm->output_unit);
+  }
+
+  cubeb_resampler_destroy(stm->resampler);
+
+#if !TARGET_OS_IPHONE
+  audiounit_uninstall_device_changed_callback(stm);
+#endif
+
+  {
+    auto_lock lock(stm->context->mutex);
+    assert(stm->context->active_streams >= 1);
+    stm->context->active_streams -= 1;
+  }
+
+  delete stm;
+}
+
+static int
+audiounit_stream_start(cubeb_stream * stm)
+{
+  {
+    auto_lock lock(stm->mutex);
+    stm->shutdown = 0;
+    stm->draining = 0;
+  }
+
+  OSStatus r;
+  if (stm->input_unit != NULL) {
+    r = AudioOutputUnitStart(stm->input_unit);
+    assert(r == 0);
+  }
+  if (stm->output_unit != NULL) {
+    r = AudioOutputUnitStart(stm->output_unit);
+    assert(r == 0);
+  }
+  stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_STARTED);
+  LOG("Cubeb stream (%p) started successfully.", stm);
+  return CUBEB_OK;
+}
+
+static int
+audiounit_stream_stop(cubeb_stream * stm)
+{
+  {
+    auto_lock lock(stm->mutex);
+    stm->shutdown = 1;
+  }
+
+  OSStatus r;
+  if (stm->input_unit != NULL) {
+    r = AudioOutputUnitStop(stm->input_unit);
+    assert(r == 0);
+  }
+  if (stm->output_unit != NULL) {
+    r = AudioOutputUnitStop(stm->output_unit);
+    assert(r == 0);
+  }
+  stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_STOPPED);
+  LOG("Cubeb stream (%p) stopped successfully.", stm);
+  return CUBEB_OK;
+}
+
+static int
+audiounit_stream_get_position(cubeb_stream * stm, uint64_t * position)
+{
+  auto_lock lock(stm->mutex);
+
+  *position = stm->frames_played;
+  return CUBEB_OK;
+}
+
+int
+audiounit_stream_get_latency(cubeb_stream * stm, uint32_t * latency)
+{
+#if TARGET_OS_IPHONE
+  //TODO
+  return CUBEB_ERROR_NOT_SUPPORTED;
+#else
+  auto_lock lock(stm->mutex);
+  if (stm->hw_latency_frames == UINT64_MAX) {
+    UInt32 size;
+    uint32_t device_latency_frames, device_safety_offset;
+    double unit_latency_sec;
+    AudioDeviceID output_device_id;
+    OSStatus r;
+    AudioObjectPropertyAddress latency_address = {
+      kAudioDevicePropertyLatency,
+      kAudioDevicePropertyScopeOutput,
+      kAudioObjectPropertyElementMaster
+    };
+    AudioObjectPropertyAddress safety_offset_address = {
+      kAudioDevicePropertySafetyOffset,
+      kAudioDevicePropertyScopeOutput,
+      kAudioObjectPropertyElementMaster
+    };
+
+    r = audiounit_get_output_device_id(&output_device_id);
+    if (r != noErr) {
+      return CUBEB_ERROR;
+    }
+
+    size = sizeof(unit_latency_sec);
+    r = AudioUnitGetProperty(stm->output_unit,
+                             kAudioUnitProperty_Latency,
+                             kAudioUnitScope_Global,
+                             0,
+                             &unit_latency_sec,
+                             &size);
+    if (r != noErr) {
+      PRINT_ERROR_CODE("AudioUnitGetProperty/kAudioUnitProperty_Latency", r);
+      return CUBEB_ERROR;
+    }
+
+    size = sizeof(device_latency_frames);
+    r = AudioObjectGetPropertyData(output_device_id,
+                                   &latency_address,
+                                   0,
+                                   NULL,
+                                   &size,
+                                   &device_latency_frames);
+    if (r != noErr) {
+      PRINT_ERROR_CODE("AudioUnitGetPropertyData/latency_frames", r);
+      return CUBEB_ERROR;
+    }
+
+    size = sizeof(device_safety_offset);
+    r = AudioObjectGetPropertyData(output_device_id,
+                                   &safety_offset_address,
+                                   0,
+                                   NULL,
+                                   &size,
+                                   &device_safety_offset);
+    if (r != noErr) {
+      PRINT_ERROR_CODE("AudioUnitGetPropertyData/safety_offset", r);
+      return CUBEB_ERROR;
+    }
+
+    /* This part is fixed and depend on the stream parameter and the hardware. */
+    stm->hw_latency_frames =
+      static_cast<uint32_t>(unit_latency_sec * stm->output_desc.mSampleRate)
+      + device_latency_frames
+      + device_safety_offset;
+  }
+
+  *latency = stm->hw_latency_frames + stm->current_latency_frames;
+
+  return CUBEB_OK;
+#endif
+}
+
+int audiounit_stream_set_volume(cubeb_stream * stm, float volume)
+{
+  OSStatus r;
+
+  r = AudioUnitSetParameter(stm->output_unit,
+                            kHALOutputParam_Volume,
+                            kAudioUnitScope_Global,
+                            0, volume, 0);
+
+  if (r != noErr) {
+    PRINT_ERROR_CODE("AudioUnitSetParameter/kHALOutputParam_Volume", r);
+    return CUBEB_ERROR;
+  }
+  return CUBEB_OK;
+}
+
+int audiounit_stream_set_panning(cubeb_stream * stm, float panning)
+{
+  if (stm->output_desc.mChannelsPerFrame > 2) {
+    return CUBEB_ERROR_INVALID_PARAMETER;
+  }
+
+  {
+    auto_lock lock(stm->mutex);
+    stm->panning = panning;
+  }
+
+  return CUBEB_OK;
+}
+
+int audiounit_stream_get_current_device(cubeb_stream * stm,
+                                        cubeb_device ** const  device)
+{
+#if TARGET_OS_IPHONE
+  //TODO
+  return CUBEB_ERROR_NOT_SUPPORTED;
+#else
+  OSStatus r;
+  UInt32 size;
+  UInt32 data;
+  char strdata[4];
+  AudioDeviceID output_device_id;
+  AudioDeviceID input_device_id;
+
+  AudioObjectPropertyAddress datasource_address = {
+    kAudioDevicePropertyDataSource,
+    kAudioDevicePropertyScopeOutput,
+    kAudioObjectPropertyElementMaster
+  };
+
+  AudioObjectPropertyAddress datasource_address_input = {
+    kAudioDevicePropertyDataSource,
+    kAudioDevicePropertyScopeInput,
+    kAudioObjectPropertyElementMaster
+  };
+
+  *device = NULL;
+
+  if (audiounit_get_output_device_id(&output_device_id) != CUBEB_OK) {
+    return CUBEB_ERROR;
+  }
+
+  *device = new cubeb_device;
+  if (!*device) {
+    return CUBEB_ERROR;
+  }
+  PodZero(*device, 1);
+
+  size = sizeof(UInt32);
+  /* This fails with some USB headset, so simply return an empty string. */
+  r = AudioObjectGetPropertyData(output_device_id,
+                                 &datasource_address,
+                                 0, NULL, &size, &data);
+  if (r != noErr) {
+    size = 0;
+    data = 0;
+  }
+
+  (*device)->output_name = new char[size + 1];
+  if (!(*device)->output_name) {
+    return CUBEB_ERROR;
+  }
+
+  // Turn the four chars packed into a uint32 into a string
+  strdata[0] = (char)(data >> 24);
+  strdata[1] = (char)(data >> 16);
+  strdata[2] = (char)(data >> 8);
+  strdata[3] = (char)(data);
+
+  memcpy((*device)->output_name, strdata, size);
+  (*device)->output_name[size] = '\0';
+
+  if (audiounit_get_input_device_id(&input_device_id) != CUBEB_OK) {
+    return CUBEB_ERROR;
+  }
+
+  size = sizeof(UInt32);
+  r = AudioObjectGetPropertyData(input_device_id, &datasource_address_input, 0, NULL, &size, &data);
+  if (r != noErr) {
+    LOG("Error when getting device !");
+    size = 0;
+    data = 0;
+  }
+
+  (*device)->input_name = new char[size + 1];
+  if (!(*device)->input_name) {
+    return CUBEB_ERROR;
+  }
+
+  // Turn the four chars packed into a uint32 into a string
+  strdata[0] = (char)(data >> 24);
+  strdata[1] = (char)(data >> 16);
+  strdata[2] = (char)(data >> 8);
+  strdata[3] = (char)(data);
+
+  memcpy((*device)->input_name, strdata, size);
+  (*device)->input_name[size] = '\0';
+
+  return CUBEB_OK;
+#endif
+}
+
+int audiounit_stream_device_destroy(cubeb_stream * stream,
+                                    cubeb_device * device)
+{
+  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)
+{
+  /* Note: second register without unregister first causes 'nope' error.
+   * Current implementation requires unregister before register a new cb. */
+  assert(!stream->device_changed_callback);
+
+  auto_lock lock(stream->mutex);
+
+  stream->device_changed_callback = device_changed_callback;
+  int r = CUBEB_OK;
+#if !TARGET_OS_IPHONE
+  if (device_changed_callback) {
+    r = audiounit_install_device_changed_callback(stream);
+  } else {
+    r = audiounit_uninstall_device_changed_callback(stream);
+  }
+#endif
+
+  return r;
+}
+
+static OSStatus
+audiounit_get_devices(AudioObjectID ** devices, uint32_t * count)
+{
+  OSStatus ret;
+  UInt32 size = 0;
+  AudioObjectPropertyAddress adr = { kAudioHardwarePropertyDevices,
+                                     kAudioObjectPropertyScopeGlobal,
+                                     kAudioObjectPropertyElementMaster };
+
+  ret = AudioObjectGetPropertyDataSize(kAudioObjectSystemObject, &adr, 0, NULL, &size);
+  if (ret != noErr) {
+    return ret;
+  }
+
+  *count = static_cast<uint32_t>(size / sizeof(AudioObjectID));
+  if (size >= sizeof(AudioObjectID)) {
+    if (*devices != NULL) {
+      delete [] (*devices);
+    }
+    *devices = new AudioObjectID[*count];
+    PodZero(*devices, *count);
+
+    ret = AudioObjectGetPropertyData(kAudioObjectSystemObject, &adr, 0, NULL, &size, (void *)*devices);
+    if (ret != noErr) {
+      delete [] (*devices);
+      *devices = NULL;
+    }
+  } else {
+    *devices = NULL;
+    ret = -1;
+  }
+
+  return ret;
+}
+
+static char *
+audiounit_strref_to_cstr_utf8(CFStringRef strref)
+{
+  CFIndex len, size;
+  char * ret;
+  if (strref == NULL) {
+    return NULL;
+  }
+
+  len = CFStringGetLength(strref);
+  size = CFStringGetMaximumSizeForEncoding(len, kCFStringEncodingUTF8);
+  ret = new char[size];
+
+  if (!CFStringGetCString(strref, ret, size, kCFStringEncodingUTF8)) {
+    delete [] ret;
+    ret = NULL;
+  }
+
+  return ret;
+}
+
+static uint32_t
+audiounit_get_channel_count(AudioObjectID devid, AudioObjectPropertyScope scope)
+{
+  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) {
+    AudioBufferList * list = static_cast<AudioBufferList *>(alloca(size));
+    if (AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, list) == noErr) {
+      for (i = 0; i < list->mNumberBuffers; i++)
+        ret += list->mBuffers[i].mNumberChannels;
+    }
+  }
+
+  return ret;
+}
+
+static void
+audiounit_get_available_samplerate(AudioObjectID devid, AudioObjectPropertyScope scope,
+                                   uint32_t * min, uint32_t * max, uint32_t * def)
+{
+  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) {
+      *def = fvalue;
+    }
+  }
+
+  adr.mSelector = kAudioDevicePropertyAvailableNominalSampleRates;
+  UInt32 size = 0;
+  AudioValueRange range;
+  if (AudioObjectHasProperty(devid, &adr) &&
+      AudioObjectGetPropertyDataSize(devid, &adr, 0, NULL, &size) == noErr) {
+    uint32_t i, count = size / sizeof(AudioValueRange);
+    AudioValueRange * ranges = new AudioValueRange[count];
+    range.mMinimum = 9999999999.0;
+    range.mMaximum = 0.0;
+    if (AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, ranges) == noErr) {
+      for (i = 0; i < count; i++) {
+        if (ranges[i].mMaximum > range.mMaximum)
+          range.mMaximum = ranges[i].mMaximum;
+        if (ranges[i].mMinimum < range.mMinimum)
+          range.mMinimum = ranges[i].mMinimum;
+      }
+    }
+    delete [] ranges;
+    *max = static_cast<uint32_t>(range.mMaximum);
+    *min = static_cast<uint32_t>(range.mMinimum);
+  } else {
+    *min = *max = 0;
+  }
+
+}
+
+static UInt32
+audiounit_get_device_presentation_latency(AudioObjectID devid, AudioObjectPropertyScope scope)
+{
+  AudioObjectPropertyAddress adr = { 0, scope, kAudioObjectPropertyElementMaster };
+  UInt32 size, dev, stream = 0, offset;
+  AudioStreamID sid[1];
+
+  adr.mSelector = kAudioDevicePropertyLatency;
+  size = sizeof(UInt32);
+  if (AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, &dev) != noErr) {
+    dev = 0;
+  }
+
+  adr.mSelector = kAudioDevicePropertyStreams;
+  size = sizeof(sid);
+  if (AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, sid) == noErr) {
+    adr.mSelector = kAudioStreamPropertyLatency;
+    size = sizeof(UInt32);
+    AudioObjectGetPropertyData(sid[0], &adr, 0, NULL, &size, &stream);
+  }
+
+  adr.mSelector = kAudioDevicePropertySafetyOffset;
+  size = sizeof(UInt32);
+  if (AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, &offset) != noErr) {
+    offset = 0;
+  }
+
+  return dev + stream + offset;
+}
+
+static cubeb_device_info *
+audiounit_create_device_from_hwdev(AudioObjectID devid, cubeb_device_type type)
+{
+  AudioObjectPropertyAddress adr = { 0, 0, kAudioObjectPropertyElementMaster };
+  UInt32 size, ch, latency;
+  cubeb_device_info * ret;
+  CFStringRef str = NULL;
+  AudioValueRange range;
+
+  if (type == CUBEB_DEVICE_TYPE_OUTPUT) {
+    adr.mScope = kAudioDevicePropertyScopeOutput;
+  } else if (type == CUBEB_DEVICE_TYPE_INPUT) {
+    adr.mScope = kAudioDevicePropertyScopeInput;
+  } else {
+    return NULL;
+  }
+
+  ch = audiounit_get_channel_count(devid, adr.mScope);
+  if (ch == 0) {
+    return NULL;
+  }
+
+  ret = new cubeb_device_info;
+  PodZero(ret, 1);
+
+  size = sizeof(CFStringRef);
+  adr.mSelector = kAudioDevicePropertyDeviceUID;
+  if (AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, &str) == noErr && str != NULL) {
+    ret->device_id = audiounit_strref_to_cstr_utf8(str);
+    ret->devid = (cubeb_devid)(size_t)devid;
+    ret->group_id = strdup(ret->device_id);
+    CFRelease(str);
+  }
+
+  size = sizeof(CFStringRef);
+  adr.mSelector = kAudioObjectPropertyName;
+  if (AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, &str) == noErr && str != NULL) {
+    UInt32 ds;
+    size = sizeof(UInt32);
+    adr.mSelector = kAudioDevicePropertyDataSource;
+    if (AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, &ds) == noErr) {
+      CFStringRef dsname;
+      AudioValueTranslation trl = { &ds, sizeof(ds), &dsname, sizeof(dsname) };
+      adr.mSelector = kAudioDevicePropertyDataSourceNameForIDCFString;
+      size = sizeof(AudioValueTranslation);
+      if (AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, &trl) == noErr) {
+        CFStringRef fullstr = CFStringCreateWithFormat(NULL, NULL,
+            CFSTR("%@ (%@)"), str, dsname);
+        CFRelease(dsname);
+        if (fullstr != NULL) {
+          CFRelease(str);
+          str = fullstr;
+        }
+      }
+    }
+
+    ret->friendly_name = audiounit_strref_to_cstr_utf8(str);
+    CFRelease(str);
+  }
+
+  size = sizeof(CFStringRef);
+  adr.mSelector = kAudioObjectPropertyManufacturer;
+  if (AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, &str) == noErr && str != NULL) {
+    ret->vendor_name = audiounit_strref_to_cstr_utf8(str);
+    CFRelease(str);
+  }
+
+  ret->type = type;
+  ret->state = CUBEB_DEVICE_STATE_ENABLED;
+  ret->preferred = (devid == audiounit_get_default_device_id(type)) ?
+    CUBEB_DEVICE_PREF_ALL : CUBEB_DEVICE_PREF_NONE;
+
+  ret->max_channels = ch;
+  ret->format = (cubeb_device_fmt)CUBEB_DEVICE_FMT_ALL; /* CoreAudio supports All! */
+  /* kAudioFormatFlagsAudioUnitCanonical is deprecated, prefer floating point */
+  ret->default_format = CUBEB_DEVICE_FMT_F32NE;
+  audiounit_get_available_samplerate(devid, adr.mScope,
+      &ret->min_rate, &ret->max_rate, &ret->default_rate);
+
+  latency = audiounit_get_device_presentation_latency(devid, adr.mScope);
+
+  adr.mSelector = kAudioDevicePropertyBufferFrameSizeRange;
+  size = sizeof(AudioValueRange);
+  if (AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, &range) == noErr) {
+    ret->latency_lo = latency + range.mMinimum;
+    ret->latency_hi = latency + range.mMaximum;
+  } else {
+    ret->latency_lo = 10 * ret->default_rate / 1000;  /* Default to  10ms */
+    ret->latency_hi = 100 * ret->default_rate / 1000; /* Default to 100ms */
+  }
+
+  return ret;
+}
+
+static int
+audiounit_enumerate_devices(cubeb * context, cubeb_device_type type,
+                            cubeb_device_collection ** collection)
+{
+  AudioObjectID * hwdevs = NULL;
+  uint32_t i, hwdevcount = 0;
+  OSStatus err;
+
+  if ((err = audiounit_get_devices(&hwdevs, &hwdevcount)) != noErr) {
+    return CUBEB_ERROR;
+  }
+
+  *collection = static_cast<cubeb_device_collection *>(malloc(sizeof(cubeb_device_collection) +
+      sizeof(cubeb_device_info*) * (hwdevcount > 0 ? hwdevcount - 1 : 0)));
+  (*collection)->count = 0;
+
+  if (hwdevcount > 0) {
+    cubeb_device_info * cur;
+
+    if (type & CUBEB_DEVICE_TYPE_OUTPUT) {
+      for (i = 0; i < hwdevcount; i++) {
+        if ((cur = audiounit_create_device_from_hwdev(hwdevs[i], CUBEB_DEVICE_TYPE_OUTPUT)) != NULL)
+          (*collection)->device[(*collection)->count++] = cur;
+      }
+    }
+
+    if (type & CUBEB_DEVICE_TYPE_INPUT) {
+      for (i = 0; i < hwdevcount; i++) {
+        if ((cur = audiounit_create_device_from_hwdev(hwdevs[i], CUBEB_DEVICE_TYPE_INPUT)) != NULL)
+          (*collection)->device[(*collection)->count++] = cur;
+      }
+    }
+  }
+
+  delete [] hwdevs;
+
+  return CUBEB_OK;
+}
+
+/* qsort compare method. */
+int compare_devid(const void * a, const void * b)
+{
+  return (*(AudioObjectID*)a - *(AudioObjectID*)b);
+}
+
+static uint32_t
+audiounit_get_devices_of_type(cubeb_device_type devtype, AudioObjectID ** devid_array)
+{
+  assert(devid_array == NULL || *devid_array == NULL);
+
+  AudioObjectPropertyAddress adr = { kAudioHardwarePropertyDevices,
+                                     kAudioObjectPropertyScopeGlobal,
+                                     kAudioObjectPropertyElementMaster };
+  UInt32 size = 0;
+  OSStatus ret = AudioObjectGetPropertyDataSize(kAudioObjectSystemObject, &adr, 0, NULL, &size);
+  if (ret != noErr) {
+    return 0;
+  }
+  /* Total number of input and output devices. */
+  uint32_t count = (uint32_t)(size / sizeof(AudioObjectID));
+
+  AudioObjectID devices[count];
+  ret = AudioObjectGetPropertyData(kAudioObjectSystemObject, &adr, 0, NULL, &size, &devices);
+  if (ret != noErr) {
+    return 0;
+  }
+  /* Expected sorted but did not find anything in the docs. */
+  qsort(devices, count, sizeof(AudioObjectID), compare_devid);
+
+  if (devtype == (CUBEB_DEVICE_TYPE_INPUT | CUBEB_DEVICE_TYPE_OUTPUT)) {
+    if (devid_array) {
+      *devid_array = new AudioObjectID[count];
+      assert(*devid_array);
+      memcpy(*devid_array, &devices, count * sizeof(AudioObjectID));
+    }
+    return count;
+  }
+
+  AudioObjectPropertyScope scope = (devtype == CUBEB_DEVICE_TYPE_INPUT) ?
+                                         kAudioDevicePropertyScopeInput :
+                                         kAudioDevicePropertyScopeOutput;
+
+  uint32_t dev_count = 0;
+  AudioObjectID devices_in_scope[count];
+  for(uint32_t i = 0; i < count; ++i) {
+    /* For device in the given scope channel must be > 0. */
+    if (audiounit_get_channel_count(devices[i], scope) > 0) {
+      devices_in_scope[dev_count] = devices[i];
+      ++dev_count;
+    }
+  }
+
+  if (devid_array && dev_count > 0) {
+    *devid_array = static_cast<AudioObjectID *>(calloc(dev_count, sizeof(AudioObjectID)));
+    assert(*devid_array);
+    memcpy(*devid_array, &devices_in_scope, dev_count * sizeof(AudioObjectID));
+  }
+  return dev_count;
+}
+
+static uint32_t
+audiounit_equal_arrays(AudioObjectID * left, AudioObjectID * right, uint32_t size)
+{
+  /* Expected sorted arrays. */
+  for (uint32_t i = 0; i < size; ++i) {
+    if (left[i] != right[i]) {
+      return 0;
+    }
+  }
+  return 1;
+}
+
+static OSStatus
+audiounit_collection_changed_callback(AudioObjectID inObjectID,
+                                      UInt32 inNumberAddresses,
+                                      const AudioObjectPropertyAddress * inAddresses,
+                                      void * inClientData)
+{
+  cubeb * context = static_cast<cubeb *>(inClientData);
+  auto_lock lock(context->mutex);
+
+  if (context->collection_changed_callback == NULL) {
+    /* Listener removed while waiting in mutex, abort. */
+    return noErr;
+  }
+
+  /* Differentiate input from output changes. */
+  if (context->collection_changed_devtype == CUBEB_DEVICE_TYPE_INPUT ||
+      context->collection_changed_devtype == CUBEB_DEVICE_TYPE_OUTPUT) {
+    AudioObjectID * devices = NULL;
+    uint32_t new_number_of_devices = audiounit_get_devices_of_type(context->collection_changed_devtype, &devices);
+    /* When count is the same examine the devid for the case of coalescing. */
+    if (context->devtype_device_count == new_number_of_devices &&
+        audiounit_equal_arrays(devices, context->devtype_device_array, new_number_of_devices)) {
+      /* Device changed for the other scope, ignore. */
+      delete [] devices;
+      return noErr;
+    }
+    /* Device on desired scope changed, reset counter and array. */
+    context->devtype_device_count = new_number_of_devices;
+    /* Free the old array before replace. */
+    delete [] context->devtype_device_array;
+    context->devtype_device_array = devices;
+  }
+
+  context->collection_changed_callback(context, context->collection_changed_user_ptr);
+  return noErr;
+}
+
+static OSStatus
+audiounit_add_device_listener(cubeb * context,
+                              cubeb_device_type devtype,
+                              cubeb_device_collection_changed_callback collection_changed_callback,
+                              void * user_ptr)
+{
+  /* Note: second register without unregister first causes 'nope' error.
+   * Current implementation requires unregister before register a new cb. */
+  assert(context->collection_changed_callback == NULL);
+
+  AudioObjectPropertyAddress devAddr;
+  devAddr.mSelector = kAudioHardwarePropertyDevices;
+  devAddr.mScope = kAudioObjectPropertyScopeGlobal;
+  devAddr.mElement = kAudioObjectPropertyElementMaster;
+
+  OSStatus ret = AudioObjectAddPropertyListener(kAudioObjectSystemObject,
+                                                &devAddr,
+                                                audiounit_collection_changed_callback,
+                                                context);
+  if (ret == noErr) {
+    /* Expected zero after unregister. */
+    assert(context->devtype_device_count == 0);
+    assert(context->devtype_device_array == NULL);
+    /* Listener works for input and output.
+     * When requested one of them we need to differentiate. */
+    if (devtype == CUBEB_DEVICE_TYPE_INPUT ||
+        devtype == CUBEB_DEVICE_TYPE_OUTPUT) {
+      /* Used to differentiate input from output device changes. */
+      context->devtype_device_count = audiounit_get_devices_of_type(devtype, &context->devtype_device_array);
+    }
+    context->collection_changed_devtype = devtype;
+    context->collection_changed_callback = collection_changed_callback;
+    context->collection_changed_user_ptr = user_ptr;
+  }
+  return ret;
+}
+
+static OSStatus
+audiounit_remove_device_listener(cubeb * context)
+{
+  AudioObjectPropertyAddress devAddr;
+  devAddr.mSelector = kAudioHardwarePropertyDevices;
+  devAddr.mScope = kAudioObjectPropertyScopeGlobal;
+  devAddr.mElement = kAudioObjectPropertyElementMaster;
+
+  /* Note: unregister a non registered cb is not a problem, not checking. */
+  OSStatus ret = AudioObjectRemovePropertyListener(kAudioObjectSystemObject,
+                                                   &devAddr,
+                                                   audiounit_collection_changed_callback,
+                                                   context);
+  if (ret == noErr) {
+    /* Reset all values. */
+    context->collection_changed_devtype = CUBEB_DEVICE_TYPE_UNKNOWN;
+    context->collection_changed_callback = NULL;
+    context->collection_changed_user_ptr = NULL;
+    context->devtype_device_count = 0;
+    if (context->devtype_device_array) {
+      delete [] context->devtype_device_array;
+      context->devtype_device_array = NULL;
+    }
+  }
+  return ret;
+}
+
+int audiounit_register_device_collection_changed(cubeb * context,
+                                                 cubeb_device_type devtype,
+                                                 cubeb_device_collection_changed_callback collection_changed_callback,
+                                                 void * user_ptr)
+{
+  OSStatus ret;
+  auto_lock lock(context->mutex);
+  if (collection_changed_callback) {
+    ret = audiounit_add_device_listener(context, devtype,
+                                        collection_changed_callback,
+                                        user_ptr);
+  } else {
+    ret = audiounit_remove_device_listener(context);
+  }
+  return (ret == noErr) ? CUBEB_OK : CUBEB_ERROR;
+}
+
+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,
+  /*.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_set_volume =*/ audiounit_stream_set_volume,
+  /*.stream_set_panning =*/ audiounit_stream_set_panning,
+  /*.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 -Naur cubeb-firefox/media/libcubeb/src/cubeb.c cubeb-upstream/media/libcubeb/src/cubeb.c
--- cubeb-firefox/media/libcubeb/src/cubeb.c	2016-07-31 15:20:25.000000000 +0500
+++ cubeb-upstream/media/libcubeb/src/cubeb.c	2016-08-03 04:39:35.689810662 +0500
@@ -66,6 +66,7 @@
 validate_stream_params(cubeb_stream_params * input_stream_params,
                        cubeb_stream_params * output_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 > 8) {
@@ -106,7 +107,7 @@
 int
 validate_latency(int latency)
 {
-  if (latency < 1 || latency > 2000) {
+  if (latency < 1 || latency > 96000) {
     return CUBEB_ERROR_INVALID_PARAMETER;
   }
   return CUBEB_OK;
@@ -453,3 +454,10 @@
   return context->ops->register_device_collection_changed(context, devtype, callback, user_ptr);
 }
 
+void cubeb_crash()
+{
+  abort();
+  *((volatile int *) NULL) = 0;
+}
+
+
diff -Naur cubeb-firefox/media/libcubeb/src/cubeb-internal.h cubeb-upstream/media/libcubeb/src/cubeb-internal.h
--- cubeb-firefox/media/libcubeb/src/cubeb-internal.h	2016-07-31 15:20:25.000000000 +0500
+++ cubeb-upstream/media/libcubeb/src/cubeb-internal.h	2016-08-03 04:39:35.686810792 +0500
@@ -11,6 +11,29 @@
 #include <stdio.h>
 #include <string.h>
 
+#ifdef __clang__
+#ifndef CLANG_ANALYZER_NORETURN
+#if __has_feature(attribute_analyzer_noreturn)
+#define CLANG_ANALYZER_NORETURN __attribute__((analyzer_noreturn))
+#else
+#define CLANG_ANALYZER_NORETURN
+#endif // ifndef CLANG_ANALYZER_NORETURN
+#endif // __has_feature(attribute_analyzer_noreturn)
+#else // __clang__
+#define CLANG_ANALYZER_NORETURN
+#endif
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/* Crash the caller.  */
+void cubeb_crash() CLANG_ANALYZER_NORETURN;
+
+#if defined(__cplusplus)
+}
+#endif
+
 struct cubeb_ops {
   int (* init)(cubeb ** context, char const * context_name);
   char const * (* get_backend_id)(cubeb * context);
@@ -52,12 +75,11 @@
                                              void * user_ptr);
 };
 
-#define XASSERT(expr) do {                                              \
-    if (!(expr)) {                                                      \
+#define XASSERT(expr) do {                                                     \
+    if (!(expr)) {                                                             \
       fprintf(stderr, "%s:%d - fatal error: %s\n", __FILE__, __LINE__, #expr); \
-      *((volatile int *) NULL) = 0;                                     \
-      abort();                                                          \
-    }                                                                   \
+      cubeb_crash();                                                           \
+    }                                                                          \
   } while (0)
 
 #endif /* CUBEB_INTERNAL_0eb56756_4e20_4404_a76d_42bf88cd15a5 */
diff -Naur cubeb-firefox/media/libcubeb/src/cubeb_jack.cpp cubeb-upstream/media/libcubeb/src/cubeb_jack.cpp
--- cubeb-firefox/media/libcubeb/src/cubeb_jack.cpp	1970-01-01 05:00:00.000000000 +0500
+++ cubeb-upstream/media/libcubeb/src/cubeb_jack.cpp	2016-08-03 04:39:35.723809181 +0500
@@ -0,0 +1,1036 @@
+/*
+ * Copyright © 2012 David Richards
+ * Copyright © 2013 Sebastien Alaiwan
+ * Copyright © 2016 Damien Zammit
+ *
+ * This program is made available under an ISC-style license.  See the
+ * accompanying file LICENSE for details.
+ */
+#define _DEFAULT_SOURCE
+#define _BSD_SOURCE
+#define _POSIX_SOURCE
+#include <algorithm>
+#include <dlfcn.h>
+#include <limits>
+#include <stdio.h>
+#include <sys/time.h>
+#include <assert.h>
+#include <string.h>
+#include <limits.h>
+#include <poll.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <math.h>
+#include "cubeb/cubeb.h"
+#include "cubeb-internal.h"
+#include "cubeb_resampler.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)
+
+#define IMPORT_FUNC(x) static decltype(x) * api_##x;
+JACK_API_VISIT(IMPORT_FUNC);
+
+static const int MAX_STREAMS = 16;
+static const int MAX_CHANNELS  = 8;
+static const int FIFO_SIZE = 4096 * sizeof(float);
+
+enum devstream {
+  NONE = 0,
+  IN_ONLY,
+  OUT_ONLY,
+  DUPLEX,
+};
+
+static void
+s16ne_to_float(float * dst, const int16_t * src, size_t n)
+{
+  for (size_t i = 0; i < n; i++)
+    *(dst++) = (float)((float)*(src++) / 32767.0f);
+}
+
+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;
+    *(dst++) = (int16_t)((int16_t)(*(src++) * 32767));
+  }
+}
+
+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_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,
+  .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_set_volume = cbjack_stream_set_volume,
+  .stream_set_panning = 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 {
+  cubeb * context;
+
+  /**< Mutex for each stream */
+  pthread_mutex_t mutex;
+
+  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;
+  cubeb_state_callback state_callback;
+  void * user_ptr;
+  cubeb_stream_params in_params;
+  cubeb_stream_params out_params;
+
+  cubeb_resampler * resampler;
+
+  uint64_t position;
+  bool pause;
+  float ratio;
+  enum devstream devs;
+  char stream_name[256];
+  jack_port_t * output_ports[MAX_CHANNELS];
+  jack_port_t * input_ports[MAX_CHANNELS];
+  float volume;
+};
+
+struct cubeb {
+  struct cubeb_ops const * ops;
+  void * libjack;
+
+  /**< Mutex for whole context */
+  pthread_mutex_t mutex;
+
+  /**< Audio buffers, converted to float */
+  float in_float_interleaved_buffer[FIFO_SIZE * MAX_CHANNELS];
+  float out_float_interleaved_buffer[FIFO_SIZE * MAX_CHANNELS];
+
+  /**< Audio buffer, at the sampling rate of the output */
+  float in_resampled_interleaved_buffer_float[FIFO_SIZE * MAX_CHANNELS * 3];
+  int16_t in_resampled_interleaved_buffer_s16ne[FIFO_SIZE * MAX_CHANNELS * 3];
+  float out_resampled_interleaved_buffer_float[FIFO_SIZE * MAX_CHANNELS * 3];
+  int16_t out_resampled_interleaved_buffer_s16ne[FIFO_SIZE * MAX_CHANNELS * 3];
+
+  cubeb_stream streams[MAX_STREAMS];
+  unsigned int active_streams;
+
+  cubeb_device_info * devinfo[2];
+  cubeb_device_collection_changed_callback collection_changed_callback;
+
+  bool active;
+  unsigned int jack_sample_rate;
+  unsigned int jack_latency;
+  unsigned int jack_xruns;
+  unsigned int jack_buffer_size;
+  unsigned int fragment_size;
+  unsigned int output_bytes_per_frame;
+  jack_client_t * jack_client;
+};
+
+static int
+load_jack_lib(cubeb * context)
+{
+#ifdef __APPLE__
+  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
+#else
+  context->libjack = dlopen("libjack.so.0", RTLD_LAZY);
+#endif
+  if (!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);
+#undef LOAD
+
+  return CUBEB_OK;
+}
+
+static void
+cbjack_connect_ports (cubeb_stream * stream)
+{
+  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) {
+    goto skipplayback;
+  }
+
+  // Connect outputs to playback
+  for (unsigned int c = 0; c < stream->out_params.channels && phys_in_ports[c] != NULL; c++) {
+    const char *src_port = api_jack_port_name (stream->output_ports[c]);
+
+    api_jack_connect (stream->context->jack_client, src_port, phys_in_ports[c]);
+  }
+
+skipplayback:
+  if (*phys_out_ports == NULL) {
+    goto end;
+  }
+  // Connect inputs to capture
+  for (unsigned int c = 0; c < stream->in_params.channels && phys_out_ports[c] != NULL; c++) {
+    const char *src_port = api_jack_port_name (stream->input_ports[c]);
+
+    api_jack_connect (stream->context->jack_client, phys_out_ports[c], src_port);
+  }
+end:
+  api_jack_free(phys_out_ports);
+  api_jack_free(phys_in_ports);
+}
+
+static int
+cbjack_xrun_callback(void * arg)
+{
+  cubeb * ctx = (cubeb *)arg;
+
+  float delay = api_jack_get_xrun_delayed_usecs(ctx->jack_client);
+  int fragments = (int)ceilf( ((delay / 1000000.0) * ctx->jack_sample_rate )
+                             / (float)(ctx->jack_buffer_size) );
+  ctx->jack_xruns += fragments;
+  return 0;
+}
+
+static int
+cbjack_graph_order_callback(void * arg)
+{
+  cubeb * ctx = (cubeb *)arg;
+  int i;
+  uint32_t rate;
+
+  jack_latency_range_t latency_range;
+  jack_nframes_t port_latency, max_latency = 0;
+
+  for (int j = 0; j < MAX_STREAMS; j++) {
+    cubeb_stream *stm = &ctx->streams[j];
+
+    if (!stm->in_use)
+      continue;
+    if (!stm->ports_ready)
+      continue;
+
+    for (i = 0; i < (int)stm->out_params.channels; ++i) {
+      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;
+    }
+    /* Cap minimum latency to 128 frames */
+    if (max_latency < 128)
+      max_latency = 128;
+  }
+
+  ctx->jack_latency = max_latency;
+
+  return 0;
+}
+
+static int
+cbjack_process(jack_nframes_t nframes, void * arg)
+{
+  cubeb * ctx = (cubeb *)arg;
+  int t_jack_xruns = ctx->jack_xruns;
+  int i;
+
+  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];
+
+    if (!stm->in_use)
+      continue;
+
+    // handle xruns by skipping audio that should have been played
+    for (i = 0; i < t_jack_xruns; i++) {
+        stm->position += ctx->fragment_size * stm->ratio;
+    }
+    ctx->jack_xruns -= t_jack_xruns;
+
+    if (!stm->ports_ready)
+      continue;
+
+    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);
+    }
+    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);
+    }
+    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];
+          for (long f = 0; f < nframes; f++) {
+            buffer_out[f] = 0.f;
+          }
+        }
+      }
+      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];
+          for (long f = 0; f < nframes; f++) {
+            buffer_in[f] = 0.f;
+          }
+        }
+      }
+    } else {
+
+      // 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;
+
+        // 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);
+          } 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);
+          }
+        } 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);
+          } 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);
+          }
+        } else if (stm->devs == OUT_ONLY) {
+          if (stm->out_params.format == CUBEB_SAMPLE_S16NE) {
+            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);
+          }
+        }
+        // unlock stream mutex
+        pthread_mutex_unlock(&stm->mutex);
+
+      } else {
+        // could not lock mutex
+        // output silence
+        if (stm->devs & OUT_ONLY) {
+          for (unsigned int c = 0; c < stm->out_params.channels; c++) {
+            float* buffer_out = bufs_out[c];
+            for (long f = 0; f < nframes; f++) {
+              buffer_out[f] = 0.f;
+            }
+          }
+        }
+        if (stm->devs & IN_ONLY) {
+          // capture silence
+          for (unsigned int c = 0; c < stm->in_params.channels; c++) {
+            float* buffer_in = bufs_in[c];
+            for (long f = 0; f < nframes; f++) {
+              buffer_in[f] = 0.f;
+            }
+          }
+        }
+      }
+    }
+  }
+  return 0;
+}
+
+
+static void
+cbjack_deinterleave_playback_refill_float(cubeb_stream * stream, float ** in, float ** bufs_out, jack_nframes_t nframes)
+{
+  float * out_interleaved_buffer = nullptr;
+
+  float * inptr = (in != NULL) ? *in : nullptr;
+  float * outptr = (bufs_out != NULL) ? *bufs_out : nullptr;
+
+  long needed_frames = (bufs_out != NULL) ? nframes : 0;
+  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);
+
+  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];
+      for (long f = 0; f < done_frames; f++) {
+        buffer[f] = out_interleaved_buffer[(f * stream->out_params.channels) + c] * stream->volume;
+      }
+      if (done_frames < needed_frames) {
+        // draining
+        for (long f = done_frames; f < needed_frames; f++) {
+          buffer[f] = 0.f;
+        }
+      }
+      if (done_frames == 0) {
+        // stop, but first zero out the existing buffer
+        for (long f = 0; f < needed_frames; f++) {
+          buffer[f] = 0.f;
+        }
+      }
+    }
+  }
+
+  if (done_frames >= 0 && done_frames < needed_frames) {
+    // set drained
+    stream->state_callback(stream, stream->user_ptr, CUBEB_STATE_DRAINED);
+    // stop stream
+    cbjack_stream_stop(stream);
+  }
+  if (done_frames > 0 && done_frames <= needed_frames) {
+    // advance stream position
+    stream->position += done_frames * stream->ratio;
+  }
+  if (done_frames < 0 || done_frames > needed_frames) {
+    // stream error
+    stream->state_callback(stream, stream->user_ptr, CUBEB_STATE_ERROR);
+  }
+}
+
+static void
+cbjack_deinterleave_playback_refill_s16ne(cubeb_stream * stream, short ** in, float ** bufs_out, jack_nframes_t nframes)
+{
+  float * out_interleaved_buffer = nullptr;
+
+  short * inptr = (in != NULL) ? *in : nullptr;
+  float * outptr = (bufs_out != NULL) ? *bufs_out : nullptr;
+
+  long needed_frames = (bufs_out != NULL) ? nframes : 0;
+  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);
+
+  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;
+
+  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];
+      for (long f = 0; f < done_frames; f++) {
+        buffer[f] = out_interleaved_buffer[(f * stream->out_params.channels) + c] * stream->volume;
+      }
+      if (done_frames < needed_frames) {
+        // draining
+        for (long f = done_frames; f < needed_frames; f++) {
+          buffer[f] = 0.f;
+        }
+      }
+      if (done_frames == 0) {
+        // stop, but first zero out the existing buffer
+        for (long f = 0; f < needed_frames; f++) {
+          buffer[f] = 0.f;
+        }
+      }
+    }
+  }
+
+  if (done_frames >= 0 && done_frames < needed_frames) {
+    // set drained
+    stream->state_callback(stream, stream->user_ptr, CUBEB_STATE_DRAINED);
+    // stop stream
+    cbjack_stream_stop(stream);
+  }
+  if (done_frames > 0 && done_frames <= needed_frames) {
+    // advance stream position
+    stream->position += done_frames * stream->ratio;
+  }
+  if (done_frames < 0 || done_frames > needed_frames) {
+    // stream error
+    stream->state_callback(stream, stream->user_ptr, CUBEB_STATE_ERROR);
+  }
+}
+
+static void
+cbjack_interleave_capture(cubeb_stream * stream, float **in, jack_nframes_t nframes, bool format_mismatch)
+{
+  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;
+    }
+  }
+  if (format_mismatch) {
+    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));
+  }
+}
+
+/*static*/ int
+jack_init (cubeb ** context, char const * context_name)
+{
+  int r;
+
+  *context = NULL;
+
+  cubeb * ctx = (cubeb *)calloc(1, sizeof(*ctx));
+  if (ctx == NULL) {
+    return CUBEB_ERROR;
+  }
+
+  r = load_jack_lib(ctx);
+  if (r != 0) {
+    cbjack_destroy(ctx);
+    return CUBEB_ERROR;
+  }
+
+  ctx->ops = &cbjack_ops;
+
+  ctx->mutex = PTHREAD_MUTEX_INITIALIZER;
+  for (r = 0; r < MAX_STREAMS; r++) {
+    ctx->streams[r].mutex = PTHREAD_MUTEX_INITIALIZER;
+  }
+
+  const char * jack_client_name = "cubeb";
+  if (context_name)
+    jack_client_name = context_name;
+
+  ctx->jack_client = api_jack_client_open(jack_client_name,
+                                          JackNoStartServer,
+                                          NULL);
+
+  if (ctx->jack_client == NULL) {
+    cbjack_destroy(ctx);
+    return CUBEB_ERROR;
+  }
+
+  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);
+
+  if (api_jack_activate (ctx->jack_client)) {
+    cbjack_destroy(ctx);
+    return CUBEB_ERROR;
+  }
+
+  ctx->jack_sample_rate = api_jack_get_sample_rate(ctx->jack_client);
+  ctx->jack_latency = 128 * 1000 / ctx->jack_sample_rate;
+
+  ctx->active = true;
+  *context = ctx;
+
+  return CUBEB_OK;
+}
+
+static char const *
+cbjack_get_backend_id(cubeb * context)
+{
+  return "jack";
+}
+
+static int
+cbjack_get_max_channel_count(cubeb * ctx, uint32_t * max_channels)
+{
+  *max_channels = MAX_CHANNELS;
+  return CUBEB_OK;
+}
+
+static int
+cbjack_get_latency(cubeb_stream * stm, unsigned int * latency_ms)
+{
+  *latency_ms = stm->context->jack_latency;
+  return CUBEB_OK;
+}
+
+static int
+cbjack_get_min_latency(cubeb * ctx, cubeb_stream_params params, uint32_t * latency_ms)
+{
+  *latency_ms = ctx->jack_latency;
+  return CUBEB_OK;
+}
+
+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);
+    if (!testclient) {
+      return CUBEB_ERROR;
+    }
+
+    *rate = api_jack_get_sample_rate(testclient);
+    api_jack_client_close(testclient);
+
+  } else {
+    *rate = api_jack_get_sample_rate(ctx->jack_client);
+  }
+  return CUBEB_OK;
+}
+
+static void
+cbjack_destroy(cubeb * context)
+{
+  context->active = false;
+
+  if (context->jack_client != NULL)
+    api_jack_client_close (context->jack_client);
+
+  if (context->libjack)
+    dlclose(context->libjack);
+
+  free(context);
+}
+
+static cubeb_stream *
+context_alloc_stream(cubeb * context, char const * stream_name)
+{
+  for (int i = 0; i < MAX_STREAMS; i++) {
+    if (!context->streams[i].in_use) {
+      cubeb_stream * stm = &context->streams[i];
+      stm->in_use = true;
+      snprintf(stm->stream_name, 255, "%s_%u", stream_name, i);
+      return stm;
+    }
+  }
+  return NULL;
+}
+
+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)
+{
+  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)
+     ) {
+    return CUBEB_ERROR_INVALID_FORMAT;
+  }
+
+  if (input_stream_params
+     && (input_stream_params->format != CUBEB_SAMPLE_FLOAT32NE &&
+         input_stream_params->format != CUBEB_SAMPLE_S16NE)
+     ) {
+    return CUBEB_ERROR_INVALID_FORMAT;
+  }
+
+  *stream = NULL;
+
+  // Find a free stream.
+  pthread_mutex_lock(&context->mutex);
+  cubeb_stream * stm = context_alloc_stream(context, stream_name);
+
+  // No free stream?
+  if (stm == NULL) {
+    pthread_mutex_unlock(&context->mutex);
+    return CUBEB_ERROR;
+  }
+
+  // unlock context mutex
+  pthread_mutex_unlock(&context->mutex);
+
+  // Lock active stream
+  pthread_mutex_lock(&stm->mutex);
+
+  stm->ports_ready = false;
+  stm->user_ptr = user_ptr;
+  stm->context = context;
+  stm->devs = NONE;
+  if (output_stream_params && !input_stream_params) {
+    stm->out_params = *output_stream_params;
+    stream_actual_rate = stm->out_params.rate;
+    stm->out_params.rate = jack_rate;
+    stm->devs = OUT_ONLY;
+    if (stm->out_params.format == CUBEB_SAMPLE_FLOAT32NE) {
+      context->output_bytes_per_frame = sizeof(float);
+    } else {
+      context->output_bytes_per_frame = sizeof(short);
+    }
+  }
+  if (input_stream_params && output_stream_params) {
+    stm->in_params = *input_stream_params;
+    stm->out_params = *output_stream_params;
+    stream_actual_rate = stm->out_params.rate;
+    stm->in_params.rate = jack_rate;
+    stm->out_params.rate = jack_rate;
+    stm->devs = DUPLEX;
+    if (stm->out_params.format == CUBEB_SAMPLE_FLOAT32NE) {
+      context->output_bytes_per_frame = sizeof(float);
+      stm->in_params.format = CUBEB_SAMPLE_FLOAT32NE;
+    } else {
+      context->output_bytes_per_frame = sizeof(short);
+      stm->in_params.format = CUBEB_SAMPLE_S16NE;
+    }
+  } else if (input_stream_params && !output_stream_params) {
+    stm->in_params = *input_stream_params;
+    stream_actual_rate = stm->in_params.rate;
+    stm->in_params.rate = jack_rate;
+    stm->devs = IN_ONLY;
+    if (stm->in_params.format == CUBEB_SAMPLE_FLOAT32NE) {
+      context->output_bytes_per_frame = sizeof(float);
+    } else {
+      context->output_bytes_per_frame = sizeof(short);
+    }
+  }
+
+  stm->ratio = (float)stream_actual_rate / (float)jack_rate;
+
+  stm->data_callback = data_callback;
+  stm->state_callback = state_callback;
+  stm->position = 0;
+  stm->volume = 1.0f;
+  context->jack_buffer_size = api_jack_get_buffer_size(context->jack_client);
+  context->fragment_size = context->jack_buffer_size;
+
+  if (stm->devs == NONE) {
+    pthread_mutex_unlock(&stm->mutex);
+    return CUBEB_ERROR;
+  }
+
+  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);
+  } 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);
+  } 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);
+  }
+
+  if (!stm->resampler) {
+    stm->in_use = false;
+    pthread_mutex_unlock(&stm->mutex);
+    return CUBEB_ERROR;
+  }
+
+  if (stm->devs == DUPLEX || stm->devs == OUT_ONLY) {
+    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 (stm->devs == DUPLEX || stm->devs == IN_ONLY) {
+    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);
+    }
+  }
+
+  cbjack_connect_ports(stm);
+
+  *stream = stm;
+
+  stm->ports_ready = true;
+  stm->pause = true;
+  pthread_mutex_unlock(&stm->mutex);
+
+  return CUBEB_OK;
+}
+
+static void
+cbjack_stream_destroy(cubeb_stream * stream)
+{
+  pthread_mutex_lock(&stream->mutex);
+  stream->ports_ready = false;
+
+  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]);
+        stream->output_ports[c] = NULL;
+      }
+    }
+  }
+
+  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]);
+        stream->input_ports[c] = NULL;
+      }
+    }
+  }
+
+  if (stream->resampler) {
+    cubeb_resampler_destroy(stream->resampler);
+    stream->resampler = NULL;
+  }
+  stream->in_use = false;
+  pthread_mutex_unlock(&stream->mutex);
+}
+
+static int
+cbjack_stream_start(cubeb_stream * stream)
+{
+  stream->pause = false;
+  stream->state_callback(stream, stream->user_ptr, CUBEB_STATE_STARTED);
+  return CUBEB_OK;
+}
+
+static int
+cbjack_stream_stop(cubeb_stream * stream)
+{
+  stream->pause = true;
+  stream->state_callback(stream, stream->user_ptr, CUBEB_STATE_STOPPED);
+  return CUBEB_OK;
+}
+
+static int
+cbjack_stream_get_position(cubeb_stream * stream, uint64_t * position)
+{
+  *position = stream->position;
+  return CUBEB_OK;
+}
+
+static int
+cbjack_stream_set_volume(cubeb_stream * stm, float volume)
+{
+  stm->volume = volume;
+  return CUBEB_OK;
+}
+
+
+static int
+cbjack_stream_get_current_device(cubeb_stream * stm, cubeb_device ** const device)
+{
+  *device = (cubeb_device *)calloc(1, sizeof(cubeb_device));
+  if (*device == NULL)
+    return CUBEB_ERROR;
+
+  const char * j_in = "JACK capture";
+  const char * j_out = "JACK playback";
+  const char * empty = "";
+
+  if (stm->devs == DUPLEX) {
+    (*device)->input_name = strdup(j_in);
+    (*device)->output_name = strdup(j_out);
+  } else if (stm->devs == IN_ONLY) {
+    (*device)->input_name = strdup(j_in);
+    (*device)->output_name = strdup(empty);
+  } else if (stm->devs == OUT_ONLY) {
+    (*device)->input_name = strdup(empty);
+    (*device)->output_name = strdup(j_out);
+  }
+
+  return CUBEB_OK;
+}
+
+static int
+cbjack_stream_device_destroy(cubeb_stream * stream,
+                             cubeb_device * device)
+{
+  if (device->input_name)
+    free(device->input_name);
+  if (device->output_name)
+    free(device->output_name);
+  free(device);
+  return CUBEB_OK;
+}
+
+static int
+cbjack_enumerate_devices(cubeb * context, cubeb_device_type type,
+                         cubeb_device_collection ** collection)
+{
+  if (!context)
+    return CUBEB_ERROR;
+
+  uint32_t rate;
+  uint8_t i = 0;
+  uint8_t j;
+  cbjack_get_preferred_sample_rate(context, &rate);
+  const char * j_in = "JACK capture";
+  const char * j_out = "JACK playback";
+
+  if (type & CUBEB_DEVICE_TYPE_OUTPUT) {
+    context->devinfo[i] = (cubeb_device_info *)malloc(sizeof(cubeb_device_info));
+    context->devinfo[i]->device_id = strdup(j_out);
+    context->devinfo[i]->devid = context->devinfo[i]->device_id;
+    context->devinfo[i]->friendly_name = strdup(j_out);
+    context->devinfo[i]->group_id = strdup(j_out);
+    context->devinfo[i]->vendor_name = strdup(j_out);
+    context->devinfo[i]->type = CUBEB_DEVICE_TYPE_OUTPUT;
+    context->devinfo[i]->state = CUBEB_DEVICE_STATE_ENABLED;
+    context->devinfo[i]->preferred = CUBEB_DEVICE_PREF_ALL;
+    context->devinfo[i]->format = CUBEB_DEVICE_FMT_F32NE;
+    context->devinfo[i]->default_format = CUBEB_DEVICE_FMT_F32NE;
+    context->devinfo[i]->max_channels = MAX_CHANNELS;
+    context->devinfo[i]->min_rate = rate;
+    context->devinfo[i]->max_rate = rate;
+    context->devinfo[i]->default_rate = rate;
+    context->devinfo[i]->latency_lo = 0;
+    context->devinfo[i]->latency_hi = 0;
+    i++;
+  }
+
+  if (type & CUBEB_DEVICE_TYPE_INPUT) {
+    context->devinfo[i] = (cubeb_device_info *)malloc(sizeof(cubeb_device_info));
+    context->devinfo[i]->device_id = strdup(j_in);
+    context->devinfo[i]->devid = context->devinfo[i]->device_id;
+    context->devinfo[i]->friendly_name = strdup(j_in);
+    context->devinfo[i]->group_id = strdup(j_in);
+    context->devinfo[i]->vendor_name = strdup(j_in);
+    context->devinfo[i]->type = CUBEB_DEVICE_TYPE_INPUT;
+    context->devinfo[i]->state = CUBEB_DEVICE_STATE_ENABLED;
+    context->devinfo[i]->preferred = CUBEB_DEVICE_PREF_ALL;
+    context->devinfo[i]->format = CUBEB_DEVICE_FMT_F32NE;
+    context->devinfo[i]->default_format = CUBEB_DEVICE_FMT_F32NE;
+    context->devinfo[i]->max_channels = MAX_CHANNELS;
+    context->devinfo[i]->min_rate = rate;
+    context->devinfo[i]->max_rate = rate;
+    context->devinfo[i]->default_rate = rate;
+    context->devinfo[i]->latency_lo = 0;
+    context->devinfo[i]->latency_hi = 0;
+    i++;
+  }
+
+  *collection = (cubeb_device_collection *)
+                 malloc(sizeof(cubeb_device_collection) +
+                        i * sizeof(cubeb_device_info *));
+
+  (*collection)->count = i;
+
+  for (j = 0; j < i; j++) {
+    (*collection)->device[j] = context->devinfo[j];
+  }
+  return CUBEB_OK;
+}
diff -Naur cubeb-firefox/media/libcubeb/src/cubeb_opensl.c cubeb-upstream/media/libcubeb/src/cubeb_opensl.c
--- cubeb-firefox/media/libcubeb/src/cubeb_opensl.c	2016-07-31 15:20:25.000000000 +0500
+++ cubeb-upstream/media/libcubeb/src/cubeb_opensl.c	2016-08-03 04:39:35.729808920 +0500
@@ -425,7 +425,7 @@
 }
 
 static int
-opensl_get_min_latency(cubeb * ctx, cubeb_stream_params params, uint32_t * latency_ms)
+opensl_get_min_latency(cubeb * ctx, cubeb_stream_params params, uint32_t * latency_frames)
 {
   /* https://android.googlesource.com/platform/ndk.git/+/master/docs/opensles/index.html
    * We don't want to deal with JNI here (and we don't have Java on b2g anyways),
@@ -475,7 +475,7 @@
   /* To get a fast track in Android's mixer, we need to be at the native
    * samplerate, which is device dependant. Some devices might be able to
    * resample when playing a fast track, but it's pretty rare. */
-  *latency_ms = NBUFS * primary_buffer_size / (primary_sampling_rate / 1000);
+  *latency_frames = NBUFS * primary_buffer_size;
 
   dlclose(libmedia);
 
@@ -502,7 +502,7 @@
                    cubeb_stream_params * input_stream_params,
                    cubeb_devid output_device,
                    cubeb_stream_params * output_stream_params,
-                   unsigned int latency,
+                   unsigned int latency_frames,
                    cubeb_data_callback data_callback, cubeb_state_callback state_callback,
                    void * user_ptr)
 {
@@ -517,11 +517,6 @@
 
   *stream = NULL;
 
-  if (output_stream_params->channels < 1 || output_stream_params->channels > 32 ||
-      latency < 1 || latency > 2000) {
-    return CUBEB_ERROR_INVALID_FORMAT;
-  }
-
   SLDataFormat_PCM format;
 
   format.formatType = SL_DATAFORMAT_PCM;
@@ -554,7 +549,7 @@
   stm->user_ptr = user_ptr;
 
   stm->inputrate = output_stream_params->rate;
-  stm->latency = latency;
+  stm->latency = latency_frames;
   stm->stream_type = output_stream_params->stream_type;
   stm->framesize = output_stream_params->channels * sizeof(int16_t);
   stm->lastPosition = -1;
@@ -594,11 +589,11 @@
   if (get_android_version() >= ANDROID_VERSION_MARSHMALLOW) {
     // Reset preferred samping rate to trigger fallback to native sampling rate.
     preferred_sampling_rate = 0;
-    if (opensl_get_min_latency(ctx, *output_stream_params, &latency) != CUBEB_OK) {
+    if (opensl_get_min_latency(ctx, *output_stream_params, &latency_frames) != CUBEB_OK) {
       // Default to AudioFlinger's advertised fast track latency of 10ms.
-      latency = 10;
+      latency_frames = 440;
     }
-    stm->latency = latency;
+    stm->latency = latency_frames;
   }
 #endif
 
@@ -627,7 +622,7 @@
 
   stm->outputrate = preferred_sampling_rate;
   stm->bytespersec = stm->outputrate * stm->framesize;
-  stm->queuebuf_len = (stm->bytespersec * latency) / (1000 * NBUFS);
+  stm->queuebuf_len = stm->framesize * latency_frames / NBUFS;
   // round up to the next multiple of stm->framesize, if needed.
   if (stm->queuebuf_len % stm->framesize) {
     stm->queuebuf_len += stm->framesize - (stm->queuebuf_len % stm->framesize);
diff -Naur cubeb-firefox/media/libcubeb/src/cubeb_osx_run_loop.h cubeb-upstream/media/libcubeb/src/cubeb_osx_run_loop.h
--- cubeb-firefox/media/libcubeb/src/cubeb_osx_run_loop.h	2016-07-31 15:20:25.000000000 +0500
+++ cubeb-upstream/media/libcubeb/src/cubeb_osx_run_loop.h	2016-08-03 04:39:35.709809791 +0500
@@ -11,4 +11,12 @@
  *
  * This has to be called only once per process, so it is in a separate header
  * for easy integration in other code bases.  */
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
 void cubeb_set_coreaudio_notification_runloop();
+
+#if defined(__cplusplus)
+}
+#endif
diff -Naur cubeb-firefox/media/libcubeb/src/cubeb_pulse.c cubeb-upstream/media/libcubeb/src/cubeb_pulse.c
--- cubeb-firefox/media/libcubeb/src/cubeb_pulse.c	2016-07-31 15:20:25.000000000 +0500
+++ cubeb-upstream/media/libcubeb/src/cubeb_pulse.c	2016-08-03 04:39:35.736808615 +0500
@@ -582,10 +582,10 @@
 }
 
 static int
-pulse_get_min_latency(cubeb * ctx, cubeb_stream_params params, uint32_t * latency_ms)
+pulse_get_min_latency(cubeb * ctx, cubeb_stream_params params, uint32_t * latency_frames)
 {
   // According to PulseAudio developers, this is a safe minimum.
-  *latency_ms = 40;
+  *latency_frames = 25 * params.rate / 1000;
 
   return CUBEB_OK;
 }
@@ -670,12 +670,12 @@
 }
 
 static pa_buffer_attr
-set_buffering_attribute(unsigned int latency, 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   = WRAP(pa_usec_to_bytes)(latency * PA_USEC_PER_MSEC, sample_spec);
+  battr.tlength   = latency_frames * WRAP(pa_frame_size)(sample_spec);
   battr.minreq    = battr.tlength / 4;
   battr.fragsize  = battr.minreq;
 
@@ -693,7 +693,7 @@
                   cubeb_stream_params * input_stream_params,
                   cubeb_devid output_device,
                   cubeb_stream_params * output_stream_params,
-                  unsigned int latency,
+                  unsigned int latency_frames,
                   cubeb_data_callback data_callback,
                   cubeb_state_callback state_callback,
                   void * user_ptr)
@@ -734,7 +734,7 @@
     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, &stm->output_sample_spec);
+    battr = set_buffering_attribute(latency_frames, &stm->output_sample_spec);
     WRAP(pa_stream_connect_playback)(stm->output_stream,
                                      output_device,
                                      &battr,
@@ -757,7 +757,7 @@
     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, &stm->input_sample_spec);
+    battr = set_buffering_attribute(latency_frames, &stm->input_sample_spec);
     WRAP(pa_stream_connect_record)(stm->input_stream,
                                    input_device,
                                    &battr,
@@ -1001,7 +1001,7 @@
   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);
+        sizeof(cubeb_device_info *) * list_data->max);
   }
 }
 
@@ -1056,8 +1056,8 @@
   devinfo->max_rate = PA_RATE_MAX;
   devinfo->default_rate = info->sample_spec.rate;
 
-  devinfo->latency_lo_ms = 40;
-  devinfo->latency_hi_ms = 400;
+  devinfo->latency_lo = 0;
+  devinfo->latency_hi = 0;
 
   pulse_ensure_dev_list_data_list_size (list_data);
   list_data->devinfo[list_data->count++] = devinfo;
@@ -1116,8 +1116,8 @@
   devinfo->max_rate = PA_RATE_MAX;
   devinfo->default_rate = info->sample_spec.rate;
 
-  devinfo->latency_lo_ms = 1;
-  devinfo->latency_hi_ms = 10;
+  devinfo->latency_lo = 0;
+  devinfo->latency_hi = 0;
 
   pulse_ensure_dev_list_data_list_size (list_data);
   list_data->devinfo[list_data->count++] = devinfo;
diff -Naur cubeb-firefox/media/libcubeb/src/cubeb_resampler.cpp cubeb-upstream/media/libcubeb/src/cubeb_resampler.cpp
--- cubeb-firefox/media/libcubeb/src/cubeb_resampler.cpp	2016-07-31 15:20:25.000000000 +0500
+++ cubeb-upstream/media/libcubeb/src/cubeb_resampler.cpp	2016-08-03 04:39:35.738808528 +0500
@@ -37,12 +37,16 @@
 long noop_resampler::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 &&
          *input_frames_count >= output_frames) ||
          (!input_buffer && (!input_frames_count || *input_frames_count == 0)) ||
          (!output_buffer && output_frames == 0));
 
   if (output_buffer == nullptr) {
+    assert(input_buffer);
     output_frames = *input_frames_count;
   }
 
@@ -131,6 +135,10 @@
                       nullptr, out_unprocessed,
                       output_frames_before_processing);
 
+  if (got < 0) {
+    return got;
+  }
+
   output_processor->written(got);
 
   /* Process the output. If not enough frames have been returned from the
@@ -156,8 +164,13 @@
   input_processor->input(input_buffer, *input_frames_count);
   resampled_input = input_processor->output(resampled_frame_count);
 
-  return 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. */
+  return (*input_frames_count) * (got / resampled_frame_count);
 }
 
 
@@ -206,6 +219,10 @@
                       resampled_input, out_unprocessed,
                       output_frames_before_processing);
 
+  if (got < 0) {
+    return got;
+  }
+
   output_processor->written(got);
 
   /* Process the output. If not enough frames have been returned from the
diff -Naur cubeb-firefox/media/libcubeb/src/cubeb_resampler_internal.h cubeb-upstream/media/libcubeb/src/cubeb_resampler_internal.h
--- cubeb-firefox/media/libcubeb/src/cubeb_resampler_internal.h	2016-07-31 15:20:25.000000000 +0500
+++ cubeb-upstream/media/libcubeb/src/cubeb_resampler_internal.h	2016-08-03 04:39:35.745808224 +0500
@@ -215,8 +215,8 @@
 
   size_t output_for_input(uint32_t input_frames)
   {
-    return ceilf(input_frames * resampling_ratio) + 1
-           - resampling_in_buffer.length() / channels;
+    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.
@@ -263,8 +263,9 @@
    * number of output frames will be exactly equal. */
   uint32_t input_needed_for_output(uint32_t output_frame_count)
   {
-    return ceilf(output_frame_count * resampling_ratio) + 1
-           - samples_to_frames(resampling_in_buffer.length());
+    return (uint32_t)ceilf((output_frame_count - samples_to_frames(resampling_out_buffer.length()))
+                          * resampling_ratio);
+
   }
 
   /** Returns a pointer to the input buffer, that contains empty space for at
@@ -331,7 +332,7 @@
   /** Additional latency inserted into the pipeline for synchronisation. */
   uint32_t additional_latency;
   /** When `input_buffer` is called, this allows tracking the number of samples
-      that where in the buffer. */
+      that were in the buffer. */
   uint32_t leftover_samples;
 };
 
diff -Naur cubeb-firefox/media/libcubeb/src/cubeb_ring_array.h cubeb-upstream/media/libcubeb/src/cubeb_ring_array.h
--- cubeb-firefox/media/libcubeb/src/cubeb_ring_array.h	2016-07-31 15:20:25.000000000 +0500
+++ cubeb-upstream/media/libcubeb/src/cubeb_ring_array.h	2016-08-03 04:39:35.749808050 +0500
@@ -8,9 +8,7 @@
 #ifndef CUBEB_RING_ARRAY_H
 #define CUBEB_RING_ARRAY_H
 
-#if defined(__cplusplus)
-extern "C" {
-#endif
+#include "cubeb_utils.h"
 
 /** Ring array of pointers is used to hold buffers. In case that
     asynchronous producer/consumer callbacks do not arrive in a
@@ -34,10 +32,11 @@
   assert(bytesPerFrame > 0 && channelsPerFrame && frames > 0);
 
   size_t size = bytesPerFrame * frames;
-  buffer->mData = calloc(1, size);
+  buffer->mData = operator new(size);
   if (buffer->mData == NULL) {
     return CUBEB_ERROR;
   }
+  PodZero(static_cast<char*>(buffer->mData), size);
 
   buffer->mNumberChannels = channelsPerFrame;
   buffer->mDataByteSize = size;
@@ -64,7 +63,8 @@
   ra->tail = 0;
   ra->count = 0;
 
-  ra->buffer_array = calloc(ra->capacity, sizeof(AudioBuffer));
+  ra->buffer_array = new AudioBuffer[ra->capacity];
+  PodZero(ra->buffer_array, ra->capacity);
   if (ra->buffer_array == NULL) {
     return CUBEB_ERROR;
   }
@@ -92,10 +92,10 @@
   }
   for (unsigned int i = 0; i < ra->capacity; ++i) {
     if (ra->buffer_array[i].mData) {
-      free(ra->buffer_array[i].mData);
+      operator delete(ra->buffer_array[i].mData);
     }
   }
-  free(ra->buffer_array);
+  delete [] ra->buffer_array;
 }
 
 /** Get the allocated buffer to be stored with fresh data.
@@ -111,7 +111,7 @@
   }
 
   assert(ra->count == 0 || (ra->tail + ra->count) % ra->capacity != ra->tail);
-  void * ret = &ra->buffer_array[(ra->tail + ra->count) % ra->capacity];
+  AudioBuffer * ret = &ra->buffer_array[(ra->tail + ra->count) % ra->capacity];
 
   ++ra->count;
   assert(ra->count <= ra->capacity);
@@ -131,7 +131,7 @@
   if (ra->count == 0) {
     return NULL;
   }
-  void * ret = &ra->buffer_array[ra->tail];
+  AudioBuffer * ret = &ra->buffer_array[ra->tail];
 
   ra->tail = (ra->tail + 1) % ra->capacity;
   assert(ra->tail < ra->capacity);
@@ -156,8 +156,4 @@
   return &ra->buffer_array[0];
 }
 
-#if defined(__cplusplus)
-}
-#endif
-
 #endif //CUBEB_RING_ARRAY_H
diff -Naur cubeb-firefox/media/libcubeb/src/cubeb_sndio.c cubeb-upstream/media/libcubeb/src/cubeb_sndio.c
--- cubeb-firefox/media/libcubeb/src/cubeb_sndio.c	2016-07-31 15:20:25.000000000 +0500
+++ cubeb-upstream/media/libcubeb/src/cubeb_sndio.c	2016-08-03 04:39:35.751807962 +0500
@@ -177,7 +177,7 @@
                   cubeb_stream_params * input_stream_params,
                   cubeb_devid output_device,
                   cubeb_stream_params * output_stream_params,
-                  unsigned int latency,
+                  unsigned int latency_frames,
                   cubeb_data_callback data_callback,
                   cubeb_state_callback state_callback,
                   void *user_ptr)
@@ -222,7 +222,7 @@
   }
   wpar.rate = output_stream_params->rate;
   wpar.pchan = output_stream_params->channels;
-  wpar.appbufsz = latency * wpar.rate / 1000;
+  wpar.appbufsz = latency_frames;
   if (!sio_setpar(s->hdl, &wpar) || !sio_getpar(s->hdl, &rpar)) {
     sio_close(s->hdl);
     free(s);
@@ -287,10 +287,10 @@
 }
 
 static int
-sndio_get_min_latency(cubeb * ctx, cubeb_stream_params params, uint32_t * latency_ms)
+sndio_get_min_latency(cubeb * ctx, cubeb_stream_params params, uint32_t * latency_frames)
 {
   // XXX Not yet implemented.
-  *latency_ms = 40;
+  *latency_frames = 2048;
 
   return CUBEB_OK;
 }
diff -Naur cubeb-firefox/media/libcubeb/src/cubeb_utils.h cubeb-upstream/media/libcubeb/src/cubeb_utils.h
--- cubeb-firefox/media/libcubeb/src/cubeb_utils.h	2016-07-31 15:20:25.000000000 +0500
+++ cubeb-upstream/media/libcubeb/src/cubeb_utils.h	2016-08-03 04:39:35.758807658 +0500
@@ -11,6 +11,11 @@
 #include <stdint.h>
 #include <string.h>
 #include <assert.h>
+#if defined(WIN32)
+#include "cubeb_utils_win.h"
+#else
+#include "cubeb_utils_unix.h"
+#endif
 
 /** Similar to memcpy, but accounts for the size of an element. */
 template<typename T>
@@ -133,6 +138,20 @@
     length_ += length;
   }
 
+  /** Prepend `length` zero-ed elements to the end of the array, resizing the
+   * array if needed.
+   * @parameter length the number of elements to prepend to the array.
+   */
+  void push_front_silence(size_t length)
+  {
+    if (length_ + length > capacity_) {
+      reserve(length + length_);
+    }
+    PodMove(data_ + length, data_, length_);
+    PodZero(data_, length);
+    length_ += length;
+  }
+
   /** Return the number of free elements in the array. */
   size_t available() const
   {
@@ -175,4 +194,18 @@
   size_t length_;
 };
 
+struct auto_lock {
+  explicit auto_lock(owned_critical_section & lock)
+    : lock(lock)
+  {
+    lock.enter();
+  }
+  ~auto_lock()
+  {
+    lock.leave();
+  }
+private:
+  owned_critical_section & lock;
+};
+
 #endif /* CUBEB_UTILS */
diff -Naur cubeb-firefox/media/libcubeb/src/cubeb_utils_unix.h cubeb-upstream/media/libcubeb/src/cubeb_utils_unix.h
--- cubeb-firefox/media/libcubeb/src/cubeb_utils_unix.h	1970-01-01 05:00:00.000000000 +0500
+++ cubeb-upstream/media/libcubeb/src/cubeb_utils_unix.h	2016-08-03 04:39:35.762807484 +0500
@@ -0,0 +1,85 @@
+/*
+ * Copyright © 2016 Mozilla Foundation
+ *
+ * This program is made available under an ISC-style license.  See the
+ * accompanying file LICENSE for details.
+ */
+
+#if !defined(CUBEB_UTILS_UNIX)
+#define CUBEB_UTILS_UNIX
+
+#include <pthread.h>
+#include <errno.h>
+#include <stdio.h>
+
+/* This wraps a critical section to track the owner in debug mode. */
+class owned_critical_section
+{
+public:
+  owned_critical_section()
+  {
+    pthread_mutexattr_t attr;
+    pthread_mutexattr_init(&attr);
+#ifdef DEBUG
+    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
+#else
+    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
+#endif
+
+#ifdef DEBUG
+    int r =
+#endif
+    pthread_mutex_init(&mutex, &attr);
+#ifdef DEBUG
+    assert(r == 0);
+#endif
+
+    pthread_mutexattr_destroy(&attr);
+  }
+
+  ~owned_critical_section()
+  {
+#ifdef DEBUG
+    int r =
+#endif
+    pthread_mutex_destroy(&mutex);
+#ifdef DEBUG
+    assert(r == 0);
+#endif
+  }
+
+  void enter()
+  {
+#ifdef DEBUG
+    int r =
+#endif
+    pthread_mutex_lock(&mutex);
+#ifdef DEBUG
+    assert(r == 0 && "Deadlock");
+#endif
+  }
+
+  void leave()
+  {
+#ifdef DEBUG
+    int r =
+#endif
+    pthread_mutex_unlock(&mutex);
+#ifdef DEBUG
+    assert(r == 0 && "Unlocking unlocked mutex");
+#endif
+  }
+
+  void assert_current_thread_owns()
+  {
+#ifdef DEBUG
+    int r = pthread_mutex_lock(&mutex);
+    assert(r == EDEADLK);
+#endif
+  }
+
+private:
+  pthread_mutex_t mutex;
+};
+
+#endif /* CUBEB_UTILS_UNIX */
diff -Naur cubeb-firefox/media/libcubeb/src/cubeb_utils_win.h cubeb-upstream/media/libcubeb/src/cubeb_utils_win.h
--- cubeb-firefox/media/libcubeb/src/cubeb_utils_win.h	1970-01-01 05:00:00.000000000 +0500
+++ cubeb-upstream/media/libcubeb/src/cubeb_utils_win.h	2016-08-03 04:39:35.766807309 +0500
@@ -0,0 +1,67 @@
+/*
+ * Copyright © 2016 Mozilla Foundation
+ *
+ * This program is made available under an ISC-style license.  See the
+ * accompanying file LICENSE for details.
+ */
+
+#if !defined(CUBEB_UTILS_WIN)
+#define CUBEB_UTILS_WIN
+
+#include <windows.h>
+#include "cubeb-internal.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
+{
+public:
+  owned_critical_section()
+#ifdef DEBUG
+    : owner(0)
+#endif
+  {
+    InitializeCriticalSection(&critical_section);
+  }
+
+  ~owned_critical_section()
+  {
+    DeleteCriticalSection(&critical_section);
+  }
+
+  void enter()
+  {
+    EnterCriticalSection(&critical_section);
+#ifdef DEBUG
+    XASSERT(owner != GetCurrentThreadId() && "recursive locking");
+    owner = GetCurrentThreadId();
+#endif
+  }
+
+  void leave()
+  {
+#ifdef DEBUG
+    /* GetCurrentThreadId cannot return 0: it is not a the valid thread id */
+    owner = 0;
+#endif
+    LeaveCriticalSection(&critical_section);
+  }
+
+  /* This is guaranteed to have the good behaviour if it succeeds. The behaviour
+     is undefined otherwise. */
+  void assert_current_thread_owns()
+  {
+#ifdef DEBUG
+    /* This implies owner != 0, because GetCurrentThreadId cannot return 0. */
+    XASSERT(owner == GetCurrentThreadId());
+#endif
+  }
+
+private:
+  CRITICAL_SECTION critical_section;
+#ifdef DEBUG
+  DWORD owner;
+#endif
+};
+
+#endif /* CUBEB_UTILS_WIN */
diff -Naur cubeb-firefox/media/libcubeb/src/cubeb_wasapi.cpp cubeb-upstream/media/libcubeb/src/cubeb_wasapi.cpp
--- cubeb-firefox/media/libcubeb/src/cubeb_wasapi.cpp	2016-07-31 15:20:25.000000000 +0500
+++ cubeb-upstream/media/libcubeb/src/cubeb_wasapi.cpp	2016-08-03 04:39:35.774806961 +0500
@@ -24,6 +24,7 @@
 #include <cmath>
 #include <algorithm>
 #include <memory>
+#include <limits>
 
 #include "cubeb/cubeb.h"
 #include "cubeb-internal.h"
@@ -61,23 +62,6 @@
   (sizeof(array_) / sizeof(array_[0]))
 
 namespace {
-uint32_t
-ms_to_hns(uint32_t ms)
-{
-  return ms * 10000;
-}
-
-uint32_t
-hns_to_ms(REFERENCE_TIME hns)
-{
-  return static_cast<uint32_t>(hns / 10000);
-}
-
-double
-hns_to_s(REFERENCE_TIME hns)
-{
-  return static_cast<double>(hns) / 10000000;
-}
 
 void
 SafeRelease(HANDLE handle)
@@ -95,73 +79,6 @@
   }
 }
 
-/* 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
-{
-public:
-  owned_critical_section()
-#ifdef DEBUG
-    : owner(0)
-#endif
-  {
-    InitializeCriticalSection(&critical_section);
-  }
-
-  ~owned_critical_section()
-  {
-    DeleteCriticalSection(&critical_section);
-  }
-
-  void enter()
-  {
-    EnterCriticalSection(&critical_section);
-#ifdef DEBUG
-    XASSERT(owner != GetCurrentThreadId() && "recursive locking");
-    owner = GetCurrentThreadId();
-#endif
-  }
-
-  void leave()
-  {
-#ifdef DEBUG
-    /* GetCurrentThreadId cannot return 0: it is not a the valid thread id */
-    owner = 0;
-#endif
-    LeaveCriticalSection(&critical_section);
-  }
-
-  /* This is guaranteed to have the good behaviour if it succeeds. The behaviour
-     is undefined otherwise. */
-  void assert_current_thread_owns()
-  {
-#ifdef DEBUG
-    /* This implies owner != 0, because GetCurrentThreadId cannot return 0. */
-    XASSERT(owner == GetCurrentThreadId());
-#endif
-  }
-
-private:
-  CRITICAL_SECTION critical_section;
-#ifdef DEBUG
-  DWORD owner;
-#endif
-};
-
-struct auto_lock {
-  auto_lock(owned_critical_section * lock)
-    : lock(lock)
-  {
-    lock->enter();
-  }
-  ~auto_lock()
-  {
-    lock->leave();
-  }
-private:
-  owned_critical_section * lock;
-};
-
 struct auto_com {
   auto_com() {
     result = CoInitializeEx(NULL, COINIT_MULTITHREADED);
@@ -239,7 +156,7 @@
   /* The input and output device, or NULL for default. */
   cubeb_devid input_device;
   cubeb_devid output_device;
-  /* The latency initially requested for this stream. */
+  /* The latency initially requested for this stream, in frames. */
   unsigned latency;
   cubeb_state_callback state_callback;
   cubeb_data_callback data_callback;
@@ -296,7 +213,7 @@
   /* The lock protects all members that are touched by the render thread or
      change during a device reset, including: audio_clock, audio_stream_volume,
      client, frames_written, mix_params, total_frames_written, prev_position. */
-  owned_critical_section * stream_reset_lock;
+  owned_critical_section stream_reset_lock;
   /* Maximum number of frames that can be passed down in a callback. */
   uint32_t input_buffer_frame_count;
   /* Maximum number of frames that can be requested in a callback. */
@@ -366,7 +283,7 @@
     LOG("Audio device default changed.\n");
 
     /* we only support a single stream type for now. */
-    if (flow != eRender && role != eMultimedia) {
+    if (flow != eRender && role != eConsole) {
       return S_OK;
     }
 
@@ -437,6 +354,50 @@
   return double(stream.rate) / mixer.rate;
 }
 
+
+uint32_t
+get_rate(cubeb_stream * stm)
+{
+  return has_input(stm) ? stm->input_stream_params.rate
+                        : stm->output_stream_params.rate;
+}
+
+uint32_t
+ms_to_hns(uint32_t ms)
+{
+  return ms * 10000;
+}
+
+uint32_t
+hns_to_ms(REFERENCE_TIME hns)
+{
+  return static_cast<uint32_t>(hns / 10000);
+}
+
+double
+hns_to_s(REFERENCE_TIME hns)
+{
+  return static_cast<double>(hns) / 10000000;
+}
+
+uint32_t
+hns_to_frames(cubeb_stream * stm, REFERENCE_TIME hns)
+{
+  return hns_to_ms(hns * get_rate(stm)) / 1000;
+}
+
+uint32_t
+hns_to_frames(uint32_t rate, REFERENCE_TIME hns)
+{
+  return hns_to_ms(hns * rate) / 1000;
+}
+
+REFERENCE_TIME
+frames_to_hns(cubeb_stream * stm, uint32_t frames)
+{
+   return frames * 1000 / get_rate(stm);
+}
+
 /* Upmix function, copies a mono channel into L and R */
 template<typename T>
 void
@@ -586,9 +547,7 @@
   /* Get input packets until we have captured enough frames, and put them in a
    * contiguous buffer. */
   uint32_t offset = 0;
-  uint32_t input_channel_count = stm->input_stream_params.channels;
-  while (offset != total_available_input * input_channel_count &&
-      total_available_input) {
+  while (offset != total_available_input) {
     hr = stm->capture_client->GetNextPacketSize(&next);
     if (FAILED(hr)) {
       LOG("cannot get next packet size: %x\n", hr);
@@ -602,37 +561,59 @@
 
     UINT32 packet_size;
     hr = stm->capture_client->GetBuffer(&input_packet,
-        &packet_size,
-        &flags,
-        &dev_pos,
-        NULL);
+                                        &packet_size,
+                                        &flags,
+                                        &dev_pos,
+                                        NULL);
     if (FAILED(hr)) {
       LOG("GetBuffer failed for capture: %x\n", hr);
       return false;
     }
     XASSERT(packet_size == next);
     if (flags & AUDCLNT_BUFFERFLAGS_SILENT) {
-      stm->linear_input_buffer.push_silence(packet_size * input_channel_count);
+      LOG("insert silence: ps=%u\n", packet_size);
+      stm->linear_input_buffer.push_silence(packet_size * stm->input_stream_params.channels);
     } else {
-      stm->linear_input_buffer.push(reinterpret_cast<float*>(input_packet),
-          packet_size * input_channel_count);
+      if (should_upmix(stm->input_mix_params, stm->input_stream_params)) {
+        bool ok = stm->linear_input_buffer.reserve(stm->linear_input_buffer.length() +
+                                                   packet_size * stm->input_stream_params.channels);
+        assert(ok);
+        upmix(reinterpret_cast<float*>(input_packet), packet_size,
+              stm->linear_input_buffer.data() + stm->linear_input_buffer.length(),
+              stm->input_mix_params.channels,
+              stm->input_stream_params.channels);
+        stm->linear_input_buffer.set_length(stm->linear_input_buffer.length() + packet_size * stm->input_stream_params.channels);
+      } else if (should_downmix(stm->input_mix_params, stm->input_stream_params)) {
+        bool ok = stm->linear_input_buffer.reserve(stm->linear_input_buffer.length() +
+                                                   packet_size * stm->input_stream_params.channels);
+        assert(ok);
+        downmix(reinterpret_cast<float*>(input_packet), packet_size,
+                stm->linear_input_buffer.data() + stm->linear_input_buffer.length(),
+                stm->input_mix_params.channels,
+                stm->input_stream_params.channels);
+        stm->linear_input_buffer.set_length(stm->linear_input_buffer.length() + packet_size * stm->input_stream_params.channels);
+      } else {
+        stm->linear_input_buffer.push(reinterpret_cast<float*>(input_packet),
+                                      packet_size * stm->input_stream_params.channels);
+      }
     }
     hr = stm->capture_client->ReleaseBuffer(packet_size);
     if (FAILED(hr)) {
       LOG("FAILED to release intput buffer");
       return false;
     }
-    offset += packet_size * input_channel_count;
+    offset += packet_size;
   }
 
-  assert(stm->linear_input_buffer.length() == total_available_input);
+  assert(stm->linear_input_buffer.length() >= total_available_input &&
+         offset == total_available_input);
 
   return true;
 }
 
 /* Get an output buffer from the render_client. It has to be released before
  * exiting the callback. */
-bool get_output_buffer(cubeb_stream * stm, float *& buffer, size_t & frame_count)
+bool get_output_buffer(cubeb_stream * stm, size_t max_frames, float *& buffer, size_t & frame_count)
 {
   UINT32 padding_out;
   HRESULT hr;
@@ -654,7 +635,7 @@
     return true;
   }
 
-  frame_count = stm->output_buffer_frame_count - padding_out;
+  frame_count = std::min<size_t>(max_frames, stm->output_buffer_frame_count - padding_out);
   BYTE * output_buffer;
 
   hr = stm->render_client->GetBuffer(frame_count, &output_buffer);
@@ -675,8 +656,9 @@
 refill_callback_duplex(cubeb_stream * stm)
 {
   HRESULT hr;
-  float * output_buffer;
-  size_t output_frames;
+  float * output_buffer = nullptr;
+  size_t output_frames = 0;
+  size_t input_frames;
   bool rv;
 
   XASSERT(has_input(stm) && has_output(stm));
@@ -686,8 +668,14 @@
     return rv;
   }
 
-  rv = get_output_buffer(stm, output_buffer, output_frames);
+  input_frames = stm->linear_input_buffer.length() / stm->input_stream_params.channels;
+  if (!input_frames) {
+    return true;
+  }
+
+  rv = get_output_buffer(stm, input_frames, output_buffer, output_frames);
   if (!rv) {
+    hr = stm->render_client->ReleaseBuffer(output_frames, 0);
     return rv;
   }
 
@@ -698,8 +686,12 @@
   }
 
   // When WASAPI has not filled the input buffer yet, send silence.
-  if (stm->linear_input_buffer.length() == 0) {
-    stm->linear_input_buffer.push_silence(output_frames* stm->output_mix_params.channels);
+  double output_duration = double(output_frames) / stm->output_mix_params.rate;
+  double input_duration = double(input_frames) / stm->input_mix_params.rate;
+  if (input_duration < output_duration) {
+    size_t padding = size_t(round((output_duration - input_duration) * stm->input_mix_params.rate));
+    LOG("padding silence: out=%f in=%f pad=%u\n", output_duration, input_duration, padding);
+    stm->linear_input_buffer.push_front_silence(padding * stm->input_stream_params.channels);
   }
 
   refill(stm,
@@ -748,20 +740,21 @@
 {
   bool rv;
   HRESULT hr;
-  float * output_buffer;
-  size_t output_frames;
+  float * output_buffer = nullptr;
+  size_t output_frames = 0;
 
   XASSERT(!has_input(stm) && has_output(stm));
 
-  rv = get_output_buffer(stm, output_buffer, output_frames);
+  rv = get_output_buffer(stm, std::numeric_limits<size_t>::max(),
+                         output_buffer, output_frames);
   if (!rv) {
     return rv;
   }
+
   if (stm->draining || output_frames == 0) {
     return true;
   }
 
-
   long got = refill(stm,
                     nullptr,
                     0,
@@ -834,6 +827,7 @@
       continue;
     }
     case WAIT_OBJECT_0 + 1: { /* reconfigure */
+      XASSERT(stm->output_client || stm->input_client);
       /* Close the stream */
       if (stm->output_client) {
         stm->output_client->Stop();
@@ -855,6 +849,7 @@
           continue;
         }
       }
+      XASSERT(stm->output_client || stm->input_client);
       if (stm->output_client) {
         stm->output_client->Start();
       }
@@ -986,11 +981,7 @@
     LOG("Could not get device enumerator: %x\n", hr);
     return hr;
   }
-  /* eMultimedia is okay for now ("Music, movies, narration, [...]").
-     We will need to change this when we distinguish streams by use-case, other
-     possible values being eConsole ("Games, system notification sounds [...]")
-     and eCommunication ("Voice communication"). */
-  hr = enumerator->GetDefaultAudioEndpoint(direction, eMultimedia, device);
+  hr = enumerator->GetDefaultAudioEndpoint(direction, eConsole, device);
   if (FAILED(hr)) {
     LOG("Could not get default audio endpoint: %x\n", hr);
     SafeRelease(enumerator);
@@ -1005,7 +996,7 @@
 double
 current_stream_delay(cubeb_stream * stm)
 {
-  stm->stream_reset_lock->assert_current_thread_owns();
+  stm->stream_reset_lock.assert_current_thread_owns();
 
   /* If the default audio endpoint went away during playback and we weren't
      able to configure a new one, it's possible the caller may call this
@@ -1039,7 +1030,7 @@
 int
 stream_set_volume(cubeb_stream * stm, float volume)
 {
-  stm->stream_reset_lock->assert_current_thread_owns();
+  stm->stream_reset_lock.assert_current_thread_owns();
 
   if (!stm->audio_stream_volume) {
     return CUBEB_ERROR;
@@ -1138,7 +1129,15 @@
     LOG("Destroy SetEvent failed: %d\n", GetLastError());
   }
 
-  DWORD r = WaitForSingleObject(stm->thread, INFINITE);
+  /* Wait five seconds for the rendering thread to return. It's supposed to
+   * check its event loop very often, five seconds is rather conservative. */
+  DWORD r = WaitForSingleObject(stm->thread, 5000);
+  if (r == WAIT_TIMEOUT) {
+    /* Something weird happened, leak the thread and continue the shutdown
+     * process. */
+    LOG("Destroy WaitForSingleObject on thread timed out,"
+        " leaking the thread: %d\n", GetLastError());
+  }
   if (r == WAIT_FAILED) {
     LOG("Destroy WaitForSingleObject on thread failed: %d\n", GetLastError());
   }
@@ -1205,7 +1204,7 @@
 }
 
 int
-wasapi_get_min_latency(cubeb * ctx, cubeb_stream_params params, uint32_t * latency_ms)
+wasapi_get_min_latency(cubeb * ctx, cubeb_stream_params params, uint32_t * latency_frames)
 {
   HRESULT hr;
   IAudioClient * client;
@@ -1243,12 +1242,13 @@
     return CUBEB_ERROR;
   }
 
-  LOG("default device period: %ld\n", default_period);
+  LOG("default device period: %lld\n", default_period);
 
   /* 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 */
-  *latency_ms = hns_to_ms(default_period);
+
+  *latency_frames = hns_to_frames(params.rate, default_period);
 
   SafeRelease(client);
 
@@ -1384,7 +1384,7 @@
   WAVEFORMATEX * mix_format;
   HRESULT hr;
 
-  stm->stream_reset_lock->assert_current_thread_owns();
+  stm->stream_reset_lock.assert_current_thread_owns();
 
   if (devid) {
     std::unique_ptr<const wchar_t> id;
@@ -1430,11 +1430,14 @@
   mix_params->format = CUBEB_SAMPLE_FLOAT32NE;
   mix_params->rate = mix_format->nSamplesPerSec;
   mix_params->channels = mix_format->nChannels;
+  LOG("Setup requested=[f=%d r=%u c=%u] mix=[f=%d r=%u c=%u]\n",
+      stream_params->format, stream_params->rate, stream_params->channels,
+      mix_params->format, mix_params->rate, mix_params->channels);
 
   hr = (*audio_client)->Initialize(AUDCLNT_SHAREMODE_SHARED,
                                    AUDCLNT_STREAMFLAGS_EVENTCALLBACK |
                                    AUDCLNT_STREAMFLAGS_NOPERSIST,
-                                   ms_to_hns(stm->latency),
+                                   frames_to_hns(stm, stm->latency),
                                    0,
                                    mix_format,
                                    NULL);
@@ -1452,8 +1455,10 @@
     return CUBEB_ERROR;
   }
 
-  if (should_upmix(*stream_params, *mix_params) ||
-      should_downmix(*stream_params, *mix_params)) {
+  // Input is up/down mixed when depacketized in get_input_buffer.
+  if (has_output(stm) &&
+      (should_upmix(*stream_params, *mix_params) ||
+       should_downmix(*stream_params, *mix_params))) {
     stm->mix_buffer = (float *)malloc(frames_to_bytes_before_mix(stm, *buffer_frame_count));
   }
 
@@ -1480,16 +1485,17 @@
   HRESULT hr;
   int rv;
 
-  stm->stream_reset_lock->assert_current_thread_owns();
+  stm->stream_reset_lock.assert_current_thread_owns();
 
   auto_com com;
   if (!com.ok()) {
     return CUBEB_ERROR;
   }
 
-  XASSERT(!stm->output_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("Setup capture: device=%x\n", (int)stm->input_device);
     rv = setup_wasapi_stream_one_side(stm,
                                       &stm->input_stream_params,
                                       stm->input_device,
@@ -1506,6 +1512,7 @@
   }
 
   if (has_output(stm)) {
+    LOG("Setup render: device=%x\n", (int)stm->output_device);
     rv = setup_wasapi_stream_one_side(stm,
                                       &stm->output_stream_params,
                                       stm->output_device,
@@ -1547,7 +1554,7 @@
   if (has_input(stm) && has_output(stm)) {
     assert(stm->input_stream_params.rate == stm->output_stream_params.rate);
     target_sample_rate = stm->input_stream_params.rate;
-  }  else if (has_input(stm)) {
+  } else if (has_input(stm)) {
     target_sample_rate = stm->input_stream_params.rate;
   } else {
     XASSERT(has_output(stm));
@@ -1596,7 +1603,7 @@
                    cubeb_stream_params * input_stream_params,
                    cubeb_devid output_device,
                    cubeb_stream_params * output_stream_params,
-                   unsigned int latency, cubeb_data_callback data_callback,
+                   unsigned int latency_frames, cubeb_data_callback data_callback,
                    cubeb_state_callback state_callback, void * user_ptr)
 {
   HRESULT hr;
@@ -1606,7 +1613,7 @@
     return CUBEB_ERROR;
   }
 
-  XASSERT(context && stream);
+  XASSERT(context && stream && (input_stream_params || output_stream_params));
 
   if (output_stream_params && output_stream_params->format != CUBEB_SAMPLE_FLOAT32NE ||
       input_stream_params && input_stream_params->format != CUBEB_SAMPLE_FLOAT32NE) {
@@ -1630,10 +1637,11 @@
     stm->output_stream_params = *output_stream_params;
     stm->output_device = output_device;
   }
-  stm->latency = latency;
+
+  stm->latency = latency_frames;
   stm->volume = 1.0;
 
-  stm->stream_reset_lock = new owned_critical_section();
+  stm->stream_reset_lock = owned_critical_section();
 
   stm->reconfigure_event = CreateEvent(NULL, 0, 0, NULL);
   if (!stm->reconfigure_event) {
@@ -1686,7 +1694,7 @@
 {
   XASSERT(stm);
 
-  stm->stream_reset_lock->assert_current_thread_owns();
+  stm->stream_reset_lock.assert_current_thread_owns();
 
   SafeRelease(stm->output_client);
   stm->output_client = NULL;
@@ -1730,8 +1738,6 @@
     close_wasapi_stream(stm);
   }
 
-  delete stm->stream_reset_lock;
-
   free(stm);
 }
 
@@ -1748,7 +1754,7 @@
   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\n",
-        dir == OUTPUT ? "output" : "input", hr);
+        dir == OUTPUT ? "output" : "input");
 
     BOOL ok = ResetEvent(stm->reconfigure_event);
     if (!ok) {
@@ -1763,9 +1769,9 @@
       return r;
     }
 
-    HRESULT hr = dir == OUTPUT ? stm->output_client->Start() : stm->input_client->Start();
-    if (FAILED(hr)) {
-      LOG("could not start the %s stream after reconfig: %x (%s)\n",
+    HRESULT hr2 = dir == OUTPUT ? stm->output_client->Start() : stm->input_client->Start();
+    if (FAILED(hr2)) {
+      LOG("could not start the %s stream after reconfig: %x\n",
           dir == OUTPUT ? "output" : "input", hr);
       return CUBEB_ERROR;
     }
@@ -1780,20 +1786,20 @@
 
 int wasapi_stream_start(cubeb_stream * stm)
 {
-  int rv;
-  auto_lock lock(stm->stream_reset_lock);
-
   XASSERT(stm && !stm->thread && !stm->shutdown_event);
+  XASSERT(stm->output_client || stm->input_client);
+
+  auto_lock lock(stm->stream_reset_lock);
 
   if (stm->output_client) {
-    rv = stream_start_one_side(stm, OUTPUT);
+    int rv = stream_start_one_side(stm, OUTPUT);
     if (rv != CUBEB_OK) {
       return rv;
     }
   }
 
   if (stm->input_client) {
-    rv = stream_start_one_side(stm, INPUT);
+    int rv = stream_start_one_side(stm, INPUT);
     if (rv != CUBEB_OK) {
       return rv;
     }
@@ -1805,7 +1811,7 @@
     return CUBEB_ERROR;
   }
 
-  stm->thread = (HANDLE) _beginthreadex(NULL, 256 * 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.\n");
     return CUBEB_ERROR;
@@ -1899,8 +1905,7 @@
   if (FAILED(hr)) {
     return CUBEB_ERROR;
   }
-  double latency_s = hns_to_s(latency_hns);
-  *latency = static_cast<uint32_t>(latency_s * stm->output_stream_params.rate);
+  *latency = hns_to_frames(stm, latency_hns);
 
   return CUBEB_OK;
 }
@@ -2049,7 +2054,7 @@
   }
 
   ret->preferred = CUBEB_DEVICE_PREF_NONE;
-  if (wasapi_is_default_device(flow, eMultimedia, device_id, enumerator))
+  if (wasapi_is_default_device(flow, eConsole, device_id, enumerator))
     ret->preferred = (cubeb_device_pref)(ret->preferred | CUBEB_DEVICE_PREF_MULTIMEDIA);
   if (wasapi_is_default_device(flow, eCommunications, device_id, enumerator))
     ret->preferred = (cubeb_device_pref)(ret->preferred | CUBEB_DEVICE_PREF_VOICE);
@@ -2093,11 +2098,11 @@
 
   if (SUCCEEDED(dev->Activate(__uuidof(IAudioClient), CLSCTX_INPROC_SERVER, NULL, (void**)&client)) &&
       SUCCEEDED(client->GetDevicePeriod(&def_period, &min_period))) {
-    ret->latency_lo_ms = hns_to_ms(min_period);
-    ret->latency_hi_ms = hns_to_ms(def_period);
+    ret->latency_lo = hns_to_frames(ret->default_rate, min_period);
+    ret->latency_hi = hns_to_frames(ret->default_rate, def_period);
   } else {
-    ret->latency_lo_ms = 0;
-    ret->latency_hi_ms = 0;
+    ret->latency_lo = 0;
+    ret->latency_hi = 0;
   }
   SafeRelease(client);
 
@@ -2137,7 +2142,7 @@
   }
 
   if (type == CUBEB_DEVICE_TYPE_OUTPUT) flow = eRender;
-  else if (type == CUBEB_DEVICE_TYPE_INPUT)  flow = eCapture;
+  else if (type == CUBEB_DEVICE_TYPE_INPUT) flow = eCapture;
   else if (type & (CUBEB_DEVICE_TYPE_INPUT | CUBEB_DEVICE_TYPE_INPUT)) flow = eAll;
   else return CUBEB_ERROR;
 
@@ -2154,6 +2159,9 @@
   }
   *out = (cubeb_device_collection *) malloc(sizeof(cubeb_device_collection) +
       sizeof(cubeb_device_info*) * (cc > 0 ? cc - 1 : 0));
+  if (!*out) {
+    return CUBEB_ERROR;
+  }
   (*out)->count = 0;
   for (i = 0; i < cc; i++) {
     hr = collection->Item(i, &dev);
diff -Naur cubeb-firefox/media/libcubeb/src/cubeb_winmm.c cubeb-upstream/media/libcubeb/src/cubeb_winmm.c
--- cubeb-firefox/media/libcubeb/src/cubeb_winmm.c	2016-07-31 15:20:25.000000000 +0500
+++ cubeb-upstream/media/libcubeb/src/cubeb_winmm.c	2016-08-03 04:39:35.779806743 +0500
@@ -89,7 +89,7 @@
   PSLIST_HEADER work;
   CRITICAL_SECTION lock;
   unsigned int active_streams;
-  unsigned int minimum_latency;
+  unsigned int minimum_latency_ms;
 };
 
 struct cubeb_stream {
@@ -207,7 +207,7 @@
       short * b = (short *) hdr->lpData;
       uint32_t i;
       for (i = 0; i < got * stm->params.channels; i++) {
-        b[i] *= stm->soft_volume;
+        b[i] = (short) (b[i] * stm->soft_volume);
       }
     }
   }
@@ -336,7 +336,7 @@
   InitializeCriticalSection(&ctx->lock);
   ctx->active_streams = 0;
 
-  ctx->minimum_latency = calculate_minimum_latency();
+  ctx->minimum_latency_ms = calculate_minimum_latency();
 
   *context = ctx;
 
@@ -384,7 +384,7 @@
                   cubeb_stream_params * input_stream_params,
                   cubeb_devid output_device,
                   cubeb_stream_params * output_stream_params,
-                  unsigned int latency,
+                  unsigned int latency_frames,
                   cubeb_data_callback data_callback,
                   cubeb_state_callback state_callback,
                   void * user_ptr)
@@ -398,7 +398,11 @@
   XASSERT(context);
   XASSERT(stream);
 
-  XASSERT(!input_stream_params && "not supported.");
+  if (input_stream_params) {
+    /* Capture support not yet implemented. */
+    return CUBEB_ERROR_NOT_SUPPORTED;
+  }
+
   if (input_device || output_device) {
     /* Device selection not yet implemented. */
     return CUBEB_ERROR_DEVICE_UNAVAILABLE;
@@ -463,11 +467,13 @@
   stm->user_ptr = user_ptr;
   stm->written = 0;
 
-  if (latency < context->minimum_latency) {
-    latency = context->minimum_latency;
+  uint32_t latency_ms = latency_frames * 1000 / output_stream_params->rate;
+
+  if (latency_ms < context->minimum_latency_ms) {
+    latency_ms = context->minimum_latency_ms;
   }
 
-  bufsz = (size_t) (stm->params.rate / 1000.0 * latency * 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));
   }
@@ -596,7 +602,7 @@
 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;
+  *latency = ctx->minimum_latency_ms * params.rate / 1000;
 
   return CUBEB_OK;
 }
@@ -697,7 +703,8 @@
     return CUBEB_ERROR;
   }
 
-  *latency = written - time.u.sample;
+  XASSERT(written - time.u.sample <= UINT32_MAX);
+  *latency = (uint32_t) (written - time.u.sample);
 
   return CUBEB_OK;
 }
@@ -783,7 +790,10 @@
 guid_to_cstr(LPGUID guid)
 {
   char * ret = malloc(sizeof(char) * 40);
-  _snprintf(ret, sizeof(char) * 40,
+  if (!ret) {
+    return NULL;
+  }
+  _snprintf_s(ret, sizeof(char) * 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],
@@ -814,7 +824,10 @@
 device_id_idx(UINT devid)
 {
   char * ret = (char *)malloc(sizeof(char)*16);
-  _snprintf(ret, 16, "%u", devid);
+  if (!ret) {
+    return NULL;
+  }
+  _snprintf_s(ret, 16, _TRUNCATE, "%u", devid);
   return ret;
 }
 
@@ -824,6 +837,9 @@
   cubeb_device_info * ret;
 
   ret = calloc(1, sizeof(cubeb_device_info));
+  if (!ret) {
+    return NULL;
+  }
   ret->devid = (cubeb_devid)(size_t)devid;
   ret->device_id = device_id_idx(devid);
   ret->friendly_name = _strdup(caps->szPname);
@@ -840,8 +856,8 @@
       &ret->format, &ret->default_format);
 
   /* Hardcoed latency estimates... */
-  ret->latency_lo_ms = 100;
-  ret->latency_hi_ms = 200;
+  ret->latency_lo = 100 * ret->default_rate / 1000;
+  ret->latency_hi = 200 * ret->default_rate / 1000;
 
   return ret;
 }
@@ -852,6 +868,9 @@
   cubeb_device_info * ret;
 
   ret = calloc(1, sizeof(cubeb_device_info));
+  if (!ret) {
+    return NULL;
+  }
   ret->devid = (cubeb_devid)(size_t)devid;
   ret->device_id = device_id_idx(devid);
   ret->friendly_name = _strdup(caps->szPname);
@@ -868,8 +887,8 @@
       &ret->format, &ret->default_format);
 
   /* Hardcoed latency estimates... */
-  ret->latency_lo_ms = 100;
-  ret->latency_hi_ms = 200;
+  ret->latency_lo = 100 * ret->default_rate / 1000;
+  ret->latency_hi = 200 * ret->default_rate / 1000;
 
   return ret;
 }
@@ -899,6 +918,9 @@
   cubeb_device_info * ret;
 
   ret = calloc(1, sizeof(cubeb_device_info));
+  if (!ret) {
+    return NULL;
+  }
   ret->devid = (cubeb_devid)(size_t)devid;
   ret->device_id = device_id_idx(devid);
   ret->friendly_name = _strdup(caps->szPname);
@@ -915,8 +937,8 @@
       &ret->format, &ret->default_format);
 
   /* Hardcoed latency estimates... */
-  ret->latency_lo_ms = 100;
-  ret->latency_hi_ms = 200;
+  ret->latency_lo = 100 * ret->default_rate / 1000;
+  ret->latency_hi = 200 * ret->default_rate / 1000;
 
   return ret;
 }
@@ -927,6 +949,9 @@
   cubeb_device_info * ret;
 
   ret = calloc(1, sizeof(cubeb_device_info));
+  if (!ret) {
+    return NULL;
+  }
   ret->devid = (cubeb_devid)(size_t)devid;
   ret->device_id = device_id_idx(devid);
   ret->friendly_name = _strdup(caps->szPname);
@@ -943,8 +968,8 @@
       &ret->format, &ret->default_format);
 
   /* Hardcoed latency estimates... */
-  ret->latency_lo_ms = 100;
-  ret->latency_hi_ms = 200;
+  ret->latency_lo = 100 * ret->default_rate / 1000;
+  ret->latency_hi = 200 * ret->default_rate / 1000;
 
   return ret;
 }
diff -Naur cubeb-firefox/media/libcubeb/src/moz.build cubeb-upstream/media/libcubeb/src/moz.build
--- cubeb-firefox/media/libcubeb/src/moz.build	2016-07-31 15:20:25.000000000 +0500
+++ cubeb-upstream/media/libcubeb/src/moz.build	2016-08-03 04:39:03.341219019 +0500
@@ -1,4 +1,4 @@
-# -*- Mode: python; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*-
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
 # vim: set filetype=python:
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -19,15 +19,28 @@
     ]
     DEFINES['USE_ALSA'] = True
 
+if CONFIG['MOZ_PULSEAUDIO'] or CONFIG['MOZ_JACK']:
+    SOURCES += [
+        'cubeb_resampler.cpp',
+    ]
+
 if CONFIG['MOZ_PULSEAUDIO']:
     SOURCES += [
         'cubeb_pulse.c',
-        'cubeb_resampler.cpp' # for tests
     ]
     DEFINES['USE_PULSE'] = True
     if CONFIG['MOZ_WIDGET_TOOLKIT'] == 'gonk':
         DEFINES['DISABLE_LIBPULSE_DLOPEN'] = True
 
+if CONFIG['MOZ_JACK']:
+    SOURCES += [
+        'cubeb_jack.cpp',
+    ]
+    USE_LIBS += [
+        'speex',
+    ]
+    DEFINES['USE_JACK'] = True
+
 if CONFIG['OS_ARCH'] == 'OpenBSD':
     SOURCES += [
         'cubeb_sndio.c',
@@ -36,7 +49,7 @@
 
 if CONFIG['OS_TARGET'] == 'Darwin':
     SOURCES += [
-        'cubeb_audiounit.c',
+        'cubeb_audiounit.cpp',
         'cubeb_resampler.cpp'
     ]
     if CONFIG['MOZ_WIDGET_TOOLKIT'] == 'cocoa':
diff -Naur cubeb-firefox/media/libcubeb/tests/test_audio.cpp cubeb-upstream/media/libcubeb/tests/test_audio.cpp
--- cubeb-firefox/media/libcubeb/tests/test_audio.cpp	2016-07-31 15:20:25.000000000 +0500
+++ cubeb-upstream/media/libcubeb/tests/test_audio.cpp	2016-08-03 04:39:35.789806308 +0500
@@ -161,7 +161,7 @@
   }
 
   r = cubeb_stream_init(ctx, &stream, "test tone", NULL, NULL, NULL, &params,
-                        100, is_float ? data_cb_float : data_cb_short, state_cb, synth);
+                        4096, is_float ? data_cb_float : data_cb_short, state_cb, synth);
   if (r != CUBEB_OK) {
     fprintf(stderr, "Error initializing cubeb stream: %d\n", r);
     goto cleanup;
@@ -213,7 +213,8 @@
   }
 
   r = cubeb_stream_init(ctx, &stream, "test tone", NULL, NULL, NULL, &params,
-                        100, is_float ? data_cb_float : data_cb_short, state_cb, synth);
+                        4096, is_float ? data_cb_float : data_cb_short,
+                        state_cb, synth);
   if (r != CUBEB_OK) {
     fprintf(stderr, "Error initializing cubeb stream: %d\n", r);
     goto cleanup;
diff -Naur cubeb-firefox/media/libcubeb/tests/test_duplex.cpp cubeb-upstream/media/libcubeb/tests/test_duplex.cpp
--- cubeb-firefox/media/libcubeb/tests/test_duplex.cpp	2016-07-31 15:20:25.000000000 +0500
+++ cubeb-upstream/media/libcubeb/tests/test_duplex.cpp	2016-08-03 04:39:35.792806178 +0500
@@ -101,7 +101,7 @@
   cubeb_stream_params output_params;
   int r;
   user_state stream_state = { false };
-  uint32_t latency_ms = 0;
+  uint32_t latency_frames = 0;
 
   r = cubeb_init(&ctx, "Cubeb duplex example");
   if (r != CUBEB_OK) {
@@ -123,7 +123,7 @@
   output_params.rate = 48000;
   output_params.channels = 2;
 
-  r = cubeb_get_min_latency(ctx, output_params, &latency_ms);
+  r = cubeb_get_min_latency(ctx, output_params, &latency_frames);
 
   if (r != CUBEB_OK) {
     fprintf(stderr, "Could not get minimal latency\n");
@@ -132,7 +132,7 @@
 
   r = cubeb_stream_init(ctx, &stream, "Cubeb duplex",
                         NULL, &input_params, NULL, &output_params,
-                        latency_ms, data_cb, state_cb, &stream_state);
+                        latency_frames, data_cb, state_cb, &stream_state);
   if (r != CUBEB_OK) {
     fprintf(stderr, "Error initializing cubeb stream\n");
     return r;
diff -Naur cubeb-firefox/media/libcubeb/tests/test_latency.cpp cubeb-upstream/media/libcubeb/tests/test_latency.cpp
--- cubeb-firefox/media/libcubeb/tests/test_latency.cpp	2016-07-31 15:20:25.000000000 +0500
+++ cubeb-upstream/media/libcubeb/tests/test_latency.cpp	2016-08-03 04:39:35.794806090 +0500
@@ -2,7 +2,7 @@
 #undef NDEBUG
 #endif
 #include <stdlib.h>
-#include <cubeb/cubeb.h>
+#include "cubeb/cubeb.h"
 #include <assert.h>
 #include <stdio.h>
 #ifdef CUBEB_GECKO_BUILD
@@ -21,7 +21,7 @@
   int r;
   uint32_t max_channels;
   uint32_t preferred_rate;
-  uint32_t latency_ms;
+  uint32_t latency_frames;
 
   LOG("latency_test start");
   r = cubeb_init(&ctx, "Cubeb audio test");
@@ -47,10 +47,10 @@
     preferred_rate,
     max_channels
   };
-  r = cubeb_get_min_latency(ctx, params, &latency_ms);
+  r = cubeb_get_min_latency(ctx, params, &latency_frames);
   assert(r == CUBEB_OK || r == CUBEB_ERROR_NOT_SUPPORTED);
   if (r == CUBEB_OK) {
-    assert(latency_ms > 0 && "Invalid minimal latency.");
+    assert(latency_frames > 0 && "Invalid minimal latency.");
     LOG("cubeb_get_min_latency ok");
   }
 
diff -Naur cubeb-firefox/media/libcubeb/tests/test_record.cpp cubeb-upstream/media/libcubeb/tests/test_record.cpp
--- cubeb-firefox/media/libcubeb/tests/test_record.cpp	2016-07-31 15:20:25.000000000 +0500
+++ cubeb-upstream/media/libcubeb/tests/test_record.cpp	2016-08-03 04:39:35.797805960 +0500
@@ -106,7 +106,7 @@
   params.channels = 1;
 
   r = cubeb_stream_init(ctx, &stream, "Cubeb record (mono)", NULL, &params, NULL, nullptr,
-                        250, data_cb, state_cb, &stream_state);
+                        4096, data_cb, state_cb, &stream_state);
   if (r != CUBEB_OK) {
     fprintf(stderr, "Error initializing cubeb stream\n");
     return r;
diff -Naur cubeb-firefox/media/libcubeb/tests/test_sanity.cpp cubeb-upstream/media/libcubeb/tests/test_sanity.cpp
--- cubeb-firefox/media/libcubeb/tests/test_sanity.cpp	2016-07-31 15:20:25.000000000 +0500
+++ cubeb-upstream/media/libcubeb/tests/test_sanity.cpp	2016-08-03 04:39:35.822804871 +0500
@@ -18,16 +18,12 @@
 #include "TestHarness.h"
 #endif
 
-#if (defined(_WIN32) || defined(__WIN32__))
-#define __func__ __FUNCTION__
-#endif
-
 #define ARRAY_LENGTH(_x) (sizeof(_x) / sizeof(_x[0]))
 #define BEGIN_TEST fprintf(stderr, "START %s\n", __func__)
 #define END_TEST fprintf(stderr, "END %s\n", __func__)
 
-#define STREAM_LATENCY 100
 #define STREAM_RATE 44100
+#define STREAM_LATENCY 100 * STREAM_RATE / 1000
 #define STREAM_CHANNELS 1
 #if (defined(_WIN32) || defined(__WIN32__))
 #define STREAM_FORMAT CUBEB_SAMPLE_FLOAT32LE
@@ -43,7 +39,6 @@
 test_data_callback(cubeb_stream * stm, void * user_ptr, const void * inputbuffer, void * outputbuffer, long nframes)
 {
   assert(stm && user_ptr == &dummy && outputbuffer && nframes > 0);
-  memset(outputbuffer, 0, nframes * sizeof(short));
 #if (defined(_WIN32) || defined(__WIN32__))
   memset(outputbuffer, 0, nframes * sizeof(float));
 #else
@@ -125,6 +120,9 @@
   params.channels = STREAM_CHANNELS;
   params.format = STREAM_FORMAT;
   params.rate = STREAM_RATE;
+#if defined(__ANDROID__)
+  params.stream_type = CUBEB_STREAM_TYPE_MUSIC;
+#endif
   r = cubeb_get_min_latency(ctx, params, &value);
   assert(r == CUBEB_OK || r == CUBEB_ERROR_NOT_SUPPORTED);
   if (r == CUBEB_OK) {
@@ -158,6 +156,9 @@
   params.format = STREAM_FORMAT;
   params.rate = STREAM_RATE;
   params.channels = STREAM_CHANNELS;
+#if defined(__ANDROID__)
+  params.stream_type = CUBEB_STREAM_TYPE_MUSIC;
+#endif
 
   r = cubeb_stream_init(ctx, &stream, "test", NULL, NULL, NULL, &params, STREAM_LATENCY,
                         test_data_callback, test_state_callback, &dummy);
@@ -186,6 +187,9 @@
   params.format = STREAM_FORMAT;
   params.rate = STREAM_RATE;
   params.channels = STREAM_CHANNELS;
+#if defined(__ANDROID__)
+  params.stream_type = CUBEB_STREAM_TYPE_MUSIC;
+#endif
 
   for (i = 0; i < ARRAY_LENGTH(stream); ++i) {
     r = cubeb_stream_init(ctx, &stream[i], "test", NULL, NULL, NULL, &params, STREAM_LATENCY,
@@ -219,6 +223,9 @@
   params.format = STREAM_FORMAT;
   params.rate = STREAM_RATE;
   params.channels = 2; // panning
+#if defined(__ANDROID__)
+  params.stream_type = CUBEB_STREAM_TYPE_MUSIC;
+#endif
 
   r = cubeb_stream_init(ctx, &stream, "test", NULL, NULL, NULL, &params, STREAM_LATENCY,
                         test_data_callback, test_state_callback, &dummy);
@@ -252,6 +259,9 @@
   params.format = STREAM_FORMAT;
   params.rate = STREAM_RATE;
   params.channels = STREAM_CHANNELS;
+#if defined(__ANDROID__)
+  params.stream_type = CUBEB_STREAM_TYPE_MUSIC;
+#endif
 
   for (i = 0; i < ARRAY_LENGTH(stream); ++i) {
     r = cubeb_stream_init(ctx, &stream[i], "test", NULL, NULL, NULL, &params, STREAM_LATENCY,
@@ -312,6 +322,9 @@
   params.format = STREAM_FORMAT;
   params.rate = STREAM_RATE;
   params.channels = STREAM_CHANNELS;
+#if defined(__ANDROID__)
+  params.stream_type = CUBEB_STREAM_TYPE_MUSIC;
+#endif
 
   for (i = 0; i < ARRAY_LENGTH(ctx); ++i) {
     r = cubeb_init(&ctx[i], "test_sanity");
@@ -352,6 +365,9 @@
   params.format = STREAM_FORMAT;
   params.rate = STREAM_RATE;
   params.channels = STREAM_CHANNELS;
+#if defined(__ANDROID__)
+  params.stream_type = CUBEB_STREAM_TYPE_MUSIC;
+#endif
 
   r = cubeb_stream_init(ctx, &stream, "test", NULL, NULL, NULL, &params, STREAM_LATENCY,
                         test_data_callback, test_state_callback, &dummy);
@@ -401,6 +417,9 @@
   params.format = STREAM_FORMAT;
   params.rate = STREAM_RATE;
   params.channels = STREAM_CHANNELS;
+#if defined(__ANDROID__)
+  params.stream_type = CUBEB_STREAM_TYPE_MUSIC;
+#endif
 
   r = cubeb_stream_init(ctx, &stream, "test", NULL, NULL, NULL, &params, STREAM_LATENCY,
                         test_data_callback, test_state_callback, &dummy);
@@ -484,7 +503,11 @@
   }
   /* once drain has started, callback must never be called again */
   assert(do_drain != 2);
+#if (defined(_WIN32) || defined(__WIN32__))
+  memset(outputbuffer, 0, nframes * sizeof(float));
+#else
   memset(outputbuffer, 0, nframes * sizeof(short));
+#endif
   total_frames_written += nframes;
   return nframes;
 }
@@ -517,6 +540,9 @@
   params.format = STREAM_FORMAT;
   params.rate = STREAM_RATE;
   params.channels = STREAM_CHANNELS;
+#if defined(__ANDROID__)
+  params.stream_type = CUBEB_STREAM_TYPE_MUSIC;
+#endif
 
   r = cubeb_stream_init(ctx, &stream, "test", NULL, NULL, NULL, &params, STREAM_LATENCY,
                         test_drain_data_callback, test_drain_state_callback, &dummy);
diff -Naur cubeb-firefox/media/libcubeb/tests/test_tone.cpp cubeb-upstream/media/libcubeb/tests/test_tone.cpp
--- cubeb-firefox/media/libcubeb/tests/test_tone.cpp	2016-07-31 15:20:25.000000000 +0500
+++ cubeb-upstream/media/libcubeb/tests/test_tone.cpp	2016-08-03 04:39:35.827804654 +0500
@@ -128,7 +128,7 @@
   user_data->position = 0;
 
   r = cubeb_stream_init(ctx, &stream, "Cubeb tone (mono)", NULL, NULL, NULL, &params,
-                        250, data_cb, state_cb, user_data);
+                        4096, data_cb, state_cb, user_data);
   if (r != CUBEB_OK) {
     fprintf(stderr, "Error initializing cubeb stream\n");
     return r;
diff -Naur cubeb-firefox/media/libcubeb/update.sh cubeb-upstream/media/libcubeb/update.sh
--- cubeb-firefox/media/libcubeb/update.sh	2016-07-31 15:20:25.000000000 +0500
+++ cubeb-upstream/media/libcubeb/update.sh	2016-08-03 04:37:58.441044622 +0500
@@ -1,40 +1,44 @@
 # Usage: sh update.sh <upstream_src_directory>
 set -e
 
+cp $1/AUTHORS .
+cp $1/LICENSE .
+cp $1/README.md .
 cp $1/include/cubeb/cubeb.h include
-cp $1/src/cubeb.c src
+cp $1/src/android/audiotrack_definitions.h src/android
+cp $1/src/android/sles_definitions.h src/android
 cp $1/src/cubeb-internal.h src
+cp $1/src/cubeb-speex-resampler.h src
+cp $1/src/cubeb.c src
 cp $1/src/cubeb_alsa.c src
-cp $1/src/cubeb_winmm.c src
-cp $1/src/cubeb_audiounit.c src
-cp $1/src/cubeb_pulse.c src
-cp $1/src/cubeb_sndio.c src
-cp $1/src/cubeb_opensl.c src
 cp $1/src/cubeb_audiotrack.c src
-cp $1/src/cubeb_wasapi.cpp src
+cp $1/src/cubeb_audiounit.cpp src
+cp $1/src/cubeb_osx_run_loop.h src
+cp $1/src/cubeb_jack.cpp src
+cp $1/src/cubeb_opensl.c src
+cp $1/src/cubeb_panner.cpp src
+cp $1/src/cubeb_panner.h src
+cp $1/src/cubeb_pulse.c src
+cp $1/src/cubeb_resampler.cpp src
 cp $1/src/cubeb_resampler.h src
 cp $1/src/cubeb_resampler_internal.h src
-cp $1/src/cubeb_resampler.cpp src
-cp $1/src/cubeb-speex-resampler.h src
-cp $1/src/cubeb_panner.h src
-cp $1/src/cubeb_panner.cpp src
-cp $1/src/cubeb_utils.h src
 cp $1/src/cubeb_ring_array.h src
-cp $1/src/android/audiotrack_definitions.h src/android
-cp $1/src/android/sles_definitions.h src/android
-cp $1/LICENSE .
-cp $1/README.md .
-cp $1/AUTHORS .
+cp $1/src/cubeb_sndio.c src
+cp $1/src/cubeb_utils.h src
+cp $1/src/cubeb_utils_unix.h src
+cp $1/src/cubeb_utils_win.h src
+cp $1/src/cubeb_wasapi.cpp src
+cp $1/src/cubeb_winmm.c src
 cp $1/test/common.h tests/common.h
 cp $1/test/test_audio.cpp tests/test_audio.cpp
-cp $1/test/test_tone.cpp tests/test_tone.cpp
-cp $1/test/test_sanity.cpp tests/test_sanity.cpp
-cp $1/test/test_latency.cpp tests/test_latency.cpp
-cp $1/test/test_resampler.cpp tests/test_resampler.cpp
+#cp $1/test/test_devices.c tests/test_devices.cpp
 cp $1/test/test_duplex.cpp tests/test_duplex.cpp
+cp $1/test/test_latency.cpp tests/test_latency.cpp
 cp $1/test/test_record.cpp tests/test_record.cpp
+cp $1/test/test_resampler.cpp tests/test_resampler.cpp
+cp $1/test/test_sanity.cpp tests/test_sanity.cpp
+cp $1/test/test_tone.cpp tests/test_tone.cpp
 cp $1/test/test_utils.cpp tests/test_utils.cpp
-#cp $1/test/test_devices.c tests/test_devices.cpp
 
 if [ -d $1/.git ]; then
   rev=$(cd $1 && git rev-parse --verify HEAD)
@@ -52,5 +56,4 @@
 else
   echo "Remember to update README_MOZILLA with the version details."
 fi
-patch -p3 < ./bug1269472.patch
 
diff -Naur cubeb-firefox/toolkit/moz.configure cubeb-upstream/toolkit/moz.configure
--- cubeb-firefox/toolkit/moz.configure	2016-07-31 15:20:28.000000000 +0500
+++ cubeb-upstream/toolkit/moz.configure	2016-08-03 04:26:36.553736626 +0500
@@ -68,6 +68,19 @@
 imply_option('--enable-jemalloc', dmd)
 imply_option('--enable-replace-malloc', dmd)
 
+# JACK cubeb backend
+# ==============================================================
+option('--enable-jack', env='MOZ_JACK',
+       help='Enable JACK audio backend.')
+
+@depends('--enable-jack')
+def jack(value):
+    if value:
+        return True
+
+set_config('MOZ_JACK', jack)
+set_define('MOZ_JACK', jack)
+
 # Javascript engine
 # ==============================================================
 include('../js/moz.configure')

Places

File firefox-900-libcubeb-with-jack-support_20160803.patch of Package MozillaFirefox (Revision c25a31b6c46be19859d4b57698d5c9a7)

Places