diff -r 000000000000 -r 6474c204b198 content/media/AudioStream.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/content/media/AudioStream.cpp	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,1144 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include <stdio.h>
+#include <math.h>
+#include "prlog.h"
+#include "prdtoa.h"
+#include "AudioStream.h"
+#include "VideoUtils.h"
+#include "mozilla/Monitor.h"
+#include "mozilla/Mutex.h"
+#include <algorithm>
+#include "mozilla/Preferences.h"
+#include "soundtouch/SoundTouch.h"
+#include "Latency.h"
+
+namespace mozilla {
+
+#ifdef LOG
+#undef LOG
+#endif
+
+#ifdef PR_LOGGING
+PRLogModuleInfo* gAudioStreamLog = nullptr;
+// For simple logs
+#define LOG(x) PR_LOG(gAudioStreamLog, PR_LOG_DEBUG, x)
+#else
+#define LOG(x)
+#endif
+
+/**
+ * When MOZ_DUMP_AUDIO is set in the environment (to anything),
+ * we'll drop a series of files in the current working directory named
+ * dumped-audio-<nnn>.wav, one per AudioStream created, containing
+ * the audio for the stream including any skips due to underruns.
+ */
+static int gDumpedAudioCount = 0;
+
+#define PREF_VOLUME_SCALE "media.volume_scale"
+#define PREF_CUBEB_LATENCY "media.cubeb_latency_ms"
+
+static const uint32_t CUBEB_NORMAL_LATENCY_MS = 100;
+
+StaticMutex AudioStream::sMutex;
+cubeb* AudioStream::sCubebContext;
+uint32_t AudioStream::sPreferredSampleRate;
+double AudioStream::sVolumeScale;
+uint32_t AudioStream::sCubebLatency;
+bool AudioStream::sCubebLatencyPrefSet;
+
+/*static*/ void AudioStream::PrefChanged(const char* aPref, void* aClosure)
+{
+  if (strcmp(aPref, PREF_VOLUME_SCALE) == 0) {
+    nsAdoptingString value = Preferences::GetString(aPref);
+    StaticMutexAutoLock lock(sMutex);
+    if (value.IsEmpty()) {
+      sVolumeScale = 1.0;
+    } else {
+      NS_ConvertUTF16toUTF8 utf8(value);
+      sVolumeScale = std::max<double>(0, PR_strtod(utf8.get(), nullptr));
+    }
+  } else if (strcmp(aPref, PREF_CUBEB_LATENCY) == 0) {
+    // Arbitrary default stream latency of 100ms.  The higher this
+    // value, the longer stream volume changes will take to become
+    // audible.
+    sCubebLatencyPrefSet = Preferences::HasUserValue(aPref);
+    uint32_t value = Preferences::GetUint(aPref, CUBEB_NORMAL_LATENCY_MS);
+    StaticMutexAutoLock lock(sMutex);
+    sCubebLatency = std::min<uint32_t>(std::max<uint32_t>(value, 1), 1000);
+  }
+}
+
+/*static*/ double AudioStream::GetVolumeScale()
+{
+  StaticMutexAutoLock lock(sMutex);
+  return sVolumeScale;
+}
+
+/*static*/ cubeb* AudioStream::GetCubebContext()
+{
+  StaticMutexAutoLock lock(sMutex);
+  return GetCubebContextUnlocked();
+}
+
+/*static*/ void AudioStream::InitPreferredSampleRate()
+{
+  StaticMutexAutoLock lock(sMutex);
+  if (sPreferredSampleRate == 0 &&
+      cubeb_get_preferred_sample_rate(GetCubebContextUnlocked(),
+                                      &sPreferredSampleRate) != CUBEB_OK) {
+    sPreferredSampleRate = 44100;
+  }
+}
+
+/*static*/ cubeb* AudioStream::GetCubebContextUnlocked()
+{
+  sMutex.AssertCurrentThreadOwns();
+  if (sCubebContext ||
+      cubeb_init(&sCubebContext, "AudioStream") == CUBEB_OK) {
+    return sCubebContext;
+  }
+  NS_WARNING("cubeb_init failed");
+  return nullptr;
+}
+
+/*static*/ uint32_t AudioStream::GetCubebLatency()
+{
+  StaticMutexAutoLock lock(sMutex);
+  return sCubebLatency;
+}
+
+/*static*/ bool AudioStream::CubebLatencyPrefSet()
+{
+  StaticMutexAutoLock lock(sMutex);
+  return sCubebLatencyPrefSet;
+}
+
+#if defined(__ANDROID__) && defined(MOZ_B2G)
+static cubeb_stream_type ConvertChannelToCubebType(dom::AudioChannel aChannel)
+{
+  switch(aChannel) {
+    case dom::AudioChannel::Normal:
+      return CUBEB_STREAM_TYPE_SYSTEM;
+    case dom::AudioChannel::Content:
+      return CUBEB_STREAM_TYPE_MUSIC;
+    case dom::AudioChannel::Notification:
+      return CUBEB_STREAM_TYPE_NOTIFICATION;
+    case dom::AudioChannel::Alarm:
+      return CUBEB_STREAM_TYPE_ALARM;
+    case dom::AudioChannel::Telephony:
+      return CUBEB_STREAM_TYPE_VOICE_CALL;
+    case dom::AudioChannel::Ringer:
+      return CUBEB_STREAM_TYPE_RING;
+    // Currently Android openSLES library doesn't support FORCE_AUDIBLE yet.
+    case dom::AudioChannel::Publicnotification:
+    default:
+      NS_ERROR("The value of AudioChannel is invalid");
+      return CUBEB_STREAM_TYPE_MAX;
+  }
+}
+#endif
+
+AudioStream::AudioStream()
+  : mMonitor("AudioStream")
+  , mInRate(0)
+  , mOutRate(0)
+  , mChannels(0)
+  , mOutChannels(0)
+  , mWritten(0)
+  , mAudioClock(MOZ_THIS_IN_INITIALIZER_LIST())
+  , mLatencyRequest(HighLatency)
+  , mReadPoint(0)
+  , mLostFrames(0)
+  , mDumpFile(nullptr)
+  , mVolume(1.0)
+  , mBytesPerFrame(0)
+  , mState(INITIALIZED)
+  , mNeedsStart(false)
+{
+  // keep a ref in case we shut down later than nsLayoutStatics
+  mLatencyLog = AsyncLatencyLogger::Get(true);
+}
+
+AudioStream::~AudioStream()
+{
+  LOG(("AudioStream: delete %p, state %d", this, mState));
+  Shutdown();
+  if (mDumpFile) {
+    fclose(mDumpFile);
+  }
+}
+
+size_t
+AudioStream::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const
+{
+  size_t amount = aMallocSizeOf(this);
+
+  // Possibly add in the future:
+  // - mTimeStretcher
+  // - mLatencyLog
+  // - mCubebStream
+
+  amount += mInserts.SizeOfExcludingThis(aMallocSizeOf);
+  amount += mBuffer.SizeOfExcludingThis(aMallocSizeOf);
+
+  return amount;
+}
+
+/*static*/ void AudioStream::InitLibrary()
+{
+#ifdef PR_LOGGING
+  gAudioStreamLog = PR_NewLogModule("AudioStream");
+#endif
+  PrefChanged(PREF_VOLUME_SCALE, nullptr);
+  Preferences::RegisterCallback(PrefChanged, PREF_VOLUME_SCALE);
+  PrefChanged(PREF_CUBEB_LATENCY, nullptr);
+  Preferences::RegisterCallback(PrefChanged, PREF_CUBEB_LATENCY);
+}
+
+/*static*/ void AudioStream::ShutdownLibrary()
+{
+  Preferences::UnregisterCallback(PrefChanged, PREF_VOLUME_SCALE);
+  Preferences::UnregisterCallback(PrefChanged, PREF_CUBEB_LATENCY);
+
+  StaticMutexAutoLock lock(sMutex);
+  if (sCubebContext) {
+    cubeb_destroy(sCubebContext);
+    sCubebContext = nullptr;
+  }
+}
+
+nsresult AudioStream::EnsureTimeStretcherInitializedUnlocked()
+{
+  mMonitor.AssertCurrentThreadOwns();
+  if (!mTimeStretcher) {
+    mTimeStretcher = new soundtouch::SoundTouch();
+    mTimeStretcher->setSampleRate(mInRate);
+    mTimeStretcher->setChannels(mOutChannels);
+    mTimeStretcher->setPitch(1.0);
+  }
+  return NS_OK;
+}
+
+nsresult AudioStream::SetPlaybackRate(double aPlaybackRate)
+{
+  NS_ASSERTION(aPlaybackRate > 0.0,
+               "Can't handle negative or null playbackrate in the AudioStream.");
+  // Avoid instantiating the resampler if we are not changing the playback rate.
+  // GetPreservesPitch/SetPreservesPitch don't need locking before calling
+  if (aPlaybackRate == mAudioClock.GetPlaybackRate()) {
+    return NS_OK;
+  }
+
+  // MUST lock since the rate transposer is used from the cubeb callback,
+  // and rate changes can cause the buffer to be reallocated
+  MonitorAutoLock mon(mMonitor);
+  if (EnsureTimeStretcherInitializedUnlocked() != NS_OK) {
+    return NS_ERROR_FAILURE;
+  }
+
+  mAudioClock.SetPlaybackRateUnlocked(aPlaybackRate);
+  mOutRate = mInRate / aPlaybackRate;
+
+  if (mAudioClock.GetPreservesPitch()) {
+    mTimeStretcher->setTempo(aPlaybackRate);
+    mTimeStretcher->setRate(1.0f);
+  } else {
+    mTimeStretcher->setTempo(1.0f);
+    mTimeStretcher->setRate(aPlaybackRate);
+  }
+  return NS_OK;
+}
+
+nsresult AudioStream::SetPreservesPitch(bool aPreservesPitch)
+{
+  // Avoid instantiating the timestretcher instance if not needed.
+  if (aPreservesPitch == mAudioClock.GetPreservesPitch()) {
+    return NS_OK;
+  }
+
+  // MUST lock since the rate transposer is used from the cubeb callback,
+  // and rate changes can cause the buffer to be reallocated
+  MonitorAutoLock mon(mMonitor);
+  if (EnsureTimeStretcherInitializedUnlocked() != NS_OK) {
+    return NS_ERROR_FAILURE;
+  }
+
+  if (aPreservesPitch == true) {
+    mTimeStretcher->setTempo(mAudioClock.GetPlaybackRate());
+    mTimeStretcher->setRate(1.0f);
+  } else {
+    mTimeStretcher->setTempo(1.0f);
+    mTimeStretcher->setRate(mAudioClock.GetPlaybackRate());
+  }
+
+  mAudioClock.SetPreservesPitch(aPreservesPitch);
+
+  return NS_OK;
+}
+
+int64_t AudioStream::GetWritten()
+{
+  return mWritten;
+}
+
+/*static*/ int AudioStream::MaxNumberOfChannels()
+{
+  cubeb* cubebContext = GetCubebContext();
+  uint32_t maxNumberOfChannels;
+  if (cubebContext &&
+      cubeb_get_max_channel_count(cubebContext,
+                                  &maxNumberOfChannels) == CUBEB_OK) {
+    return static_cast<int>(maxNumberOfChannels);
+  }
+
+  return 0;
+}
+
+/*static*/ int AudioStream::PreferredSampleRate()
+{
+  MOZ_ASSERT(sPreferredSampleRate,
+             "sPreferredSampleRate has not been initialized!");
+  return sPreferredSampleRate;
+}
+
+static void SetUint16LE(uint8_t* aDest, uint16_t aValue)
+{
+  aDest[0] = aValue & 0xFF;
+  aDest[1] = aValue >> 8;
+}
+
+static void SetUint32LE(uint8_t* aDest, uint32_t aValue)
+{
+  SetUint16LE(aDest, aValue & 0xFFFF);
+  SetUint16LE(aDest + 2, aValue >> 16);
+}
+
+static FILE*
+OpenDumpFile(AudioStream* aStream)
+{
+  if (!getenv("MOZ_DUMP_AUDIO"))
+    return nullptr;
+  char buf[100];
+  sprintf(buf, "dumped-audio-%d.wav", gDumpedAudioCount);
+  FILE* f = fopen(buf, "wb");
+  if (!f)
+    return nullptr;
+  ++gDumpedAudioCount;
+
+  uint8_t header[] = {
+    // RIFF header
+    0x52, 0x49, 0x46, 0x46, 0x00, 0x00, 0x00, 0x00, 0x57, 0x41, 0x56, 0x45,
+    // fmt chunk. We always write 16-bit samples.
+    0x66, 0x6d, 0x74, 0x20, 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x10, 0x00,
+    // data chunk
+    0x64, 0x61, 0x74, 0x61, 0xFE, 0xFF, 0xFF, 0x7F
+  };
+  static const int CHANNEL_OFFSET = 22;
+  static const int SAMPLE_RATE_OFFSET = 24;
+  static const int BLOCK_ALIGN_OFFSET = 32;
+  SetUint16LE(header + CHANNEL_OFFSET, aStream->GetChannels());
+  SetUint32LE(header + SAMPLE_RATE_OFFSET, aStream->GetRate());
+  SetUint16LE(header + BLOCK_ALIGN_OFFSET, aStream->GetChannels()*2);
+  fwrite(header, sizeof(header), 1, f);
+
+  return f;
+}
+
+static void
+WriteDumpFile(FILE* aDumpFile, AudioStream* aStream, uint32_t aFrames,
+              void* aBuffer)
+{
+  if (!aDumpFile)
+    return;
+
+  uint32_t samples = aStream->GetOutChannels()*aFrames;
+  if (AUDIO_OUTPUT_FORMAT == AUDIO_FORMAT_S16) {
+    fwrite(aBuffer, 2, samples, aDumpFile);
+    return;
+  }
+
+  NS_ASSERTION(AUDIO_OUTPUT_FORMAT == AUDIO_FORMAT_FLOAT32, "bad format");
+  nsAutoTArray<uint8_t, 1024*2> buf;
+  buf.SetLength(samples*2);
+  float* input = static_cast<float*>(aBuffer);
+  uint8_t* output = buf.Elements();
+  for (uint32_t i = 0; i < samples; ++i) {
+    SetUint16LE(output + i*2, int16_t(input[i]*32767.0f));
+  }
+  fwrite(output, 2, samples, aDumpFile);
+  fflush(aDumpFile);
+}
+
+// NOTE: this must not block a LowLatency stream for any significant amount
+// of time, or it will block the entirety of MSG
+nsresult
+AudioStream::Init(int32_t aNumChannels, int32_t aRate,
+                  const dom::AudioChannel aAudioChannel,
+                  LatencyRequest aLatencyRequest)
+{
+  if (!GetCubebContext() || aNumChannels < 0 || aRate < 0) {
+    return NS_ERROR_FAILURE;
+  }
+
+  PR_LOG(gAudioStreamLog, PR_LOG_DEBUG,
+    ("%s  channels: %d, rate: %d for %p", __FUNCTION__, aNumChannels, aRate, this));
+  mInRate = mOutRate = aRate;
+  mChannels = aNumChannels;
+  mOutChannels = (aNumChannels > 2) ? 2 : aNumChannels;
+  mLatencyRequest = aLatencyRequest;
+
+  mDumpFile = OpenDumpFile(this);
+
+  cubeb_stream_params params;
+  params.rate = aRate;
+  params.channels = mOutChannels;
+#if defined(__ANDROID__)
+#if defined(MOZ_B2G)
+  params.stream_type = ConvertChannelToCubebType(aAudioChannel);
+#else
+  params.stream_type = CUBEB_STREAM_TYPE_MUSIC;
+#endif
+
+  if (params.stream_type == CUBEB_STREAM_TYPE_MAX) {
+    return NS_ERROR_INVALID_ARG;
+  }
+#endif
+  if (AUDIO_OUTPUT_FORMAT == AUDIO_FORMAT_S16) {
+    params.format = CUBEB_SAMPLE_S16NE;
+  } else {
+    params.format = CUBEB_SAMPLE_FLOAT32NE;
+  }
+  mBytesPerFrame = sizeof(AudioDataValue) * mOutChannels;
+
+  mAudioClock.Init();
+
+  // Size mBuffer for one second of audio.  This value is arbitrary, and was
+  // selected based on the observed behaviour of the existing AudioStream
+  // implementations.
+  uint32_t bufferLimit = FramesToBytes(aRate);
+  NS_ABORT_IF_FALSE(bufferLimit % mBytesPerFrame == 0, "Must buffer complete frames");
+  mBuffer.SetCapacity(bufferLimit);
+
+  if (aLatencyRequest == LowLatency) {
+    // Don't block this thread to initialize a cubeb stream.
+    // When this is done, it will start callbacks from Cubeb.  Those will
+    // cause us to move from INITIALIZED to RUNNING.  Until then, we
+    // can't access any cubeb functions.
+    // Use a RefPtr to avoid leaks if Dispatch fails
+    RefPtr<AudioInitTask> init = new AudioInitTask(this, aLatencyRequest, params);
+    init->Dispatch();
+    return NS_OK;
+  }
+  // High latency - open synchronously
+  nsresult rv = OpenCubeb(params, aLatencyRequest);
+  // See if we need to start() the stream, since we must do that from this
+  // thread for now (cubeb API issue)
+  CheckForStart();
+  return rv;
+}
+
+// This code used to live inside AudioStream::Init(), but on Mac (others?)
+// it has been known to take 300-800 (or even 8500) ms to execute(!)
+nsresult
+AudioStream::OpenCubeb(cubeb_stream_params &aParams,
+                       LatencyRequest aLatencyRequest)
+{
+  cubeb* cubebContext = GetCubebContext();
+  if (!cubebContext) {
+    MonitorAutoLock mon(mMonitor);
+    mState = AudioStream::ERRORED;
+    return NS_ERROR_FAILURE;
+  }
+
+  // If the latency pref is set, use it. Otherwise, if this stream is intended
+  // for low latency playback, try to get the lowest latency possible.
+  // Otherwise, for normal streams, use 100ms.
+  uint32_t latency;
+  if (aLatencyRequest == LowLatency && !CubebLatencyPrefSet()) {
+    if (cubeb_get_min_latency(cubebContext, aParams, &latency) != CUBEB_OK) {
+      latency = GetCubebLatency();
+    }
+  } else {
+    latency = GetCubebLatency();
+  }
+
+  {
+    cubeb_stream* stream;
+    if (cubeb_stream_init(cubebContext, &stream, "AudioStream", aParams,
+                          latency, DataCallback_S, StateCallback_S, this) == CUBEB_OK) {
+      MonitorAutoLock mon(mMonitor);
+      mCubebStream.own(stream);
+      // Make sure we weren't shut down while in flight!
+      if (mState == SHUTDOWN) {
+        mCubebStream.reset();
+        LOG(("AudioStream::OpenCubeb() %p Shutdown while opening cubeb", this));
+        return NS_ERROR_FAILURE;
+      }
+
+      // We can't cubeb_stream_start() the thread from a transient thread due to
+      // cubeb API requirements (init can be called from another thread, but
+      // not start/stop/destroy/etc)
+    } else {
+      MonitorAutoLock mon(mMonitor);
+      mState = ERRORED;
+      LOG(("AudioStream::OpenCubeb() %p failed to init cubeb", this));
+      return NS_ERROR_FAILURE;
+    }
+  }
+
+  return NS_OK;
+}
+
+void
+AudioStream::CheckForStart()
+{
+  if (mState == INITIALIZED) {
+    // Start the stream right away when low latency has been requested. This means
+    // that the DataCallback will feed silence to cubeb, until the first frames
+    // are written to this AudioStream.  Also start if a start has been queued.
+    if (mLatencyRequest == LowLatency || mNeedsStart) {
+      StartUnlocked(); // mState = STARTED or ERRORED
+      mNeedsStart = false;
+      PR_LOG(gAudioStreamLog, PR_LOG_WARNING,
+             ("Started waiting %s-latency stream",
+              mLatencyRequest == LowLatency ? "low" : "high"));
+    } else {
+      // high latency, not full - OR Pause() was called before we got here
+      PR_LOG(gAudioStreamLog, PR_LOG_DEBUG,
+             ("Not starting waiting %s-latency stream",
+              mLatencyRequest == LowLatency ? "low" : "high"));
+    }
+  }
+}
+
+NS_IMETHODIMP
+AudioInitTask::Run()
+{
+  MOZ_ASSERT(mThread);
+  if (NS_IsMainThread()) {
+    mThread->Shutdown(); // can't Shutdown from the thread itself, darn
+    // Don't null out mThread!
+    // See bug 999104.  We must hold a ref to the thread across Dispatch()
+    // since the internal mThread ref could be released while processing
+    // the Dispatch(), and Dispatch/PutEvent itself doesn't hold a ref; it
+    // assumes the caller does.
+    return NS_OK;
+  }
+
+  nsresult rv = mAudioStream->OpenCubeb(mParams, mLatencyRequest);
+
+  // and now kill this thread
+  NS_DispatchToMainThread(this);
+  return rv;
+}
+
+// aTime is the time in ms the samples were inserted into MediaStreamGraph
+nsresult
+AudioStream::Write(const AudioDataValue* aBuf, uint32_t aFrames, TimeStamp *aTime)
+{
+  MonitorAutoLock mon(mMonitor);
+  if (mState == ERRORED) {
+    return NS_ERROR_FAILURE;
+  }
+  NS_ASSERTION(mState == INITIALIZED || mState == STARTED || mState == RUNNING,
+    "Stream write in unexpected state.");
+
+  // See if we need to start() the stream, since we must do that from this thread
+  CheckForStart();
+
+  // Downmix to Stereo.
+  if (mChannels > 2 && mChannels <= 8) {
+    DownmixAudioToStereo(const_cast<AudioDataValue*> (aBuf), mChannels, aFrames);
+  }
+  else if (mChannels > 8) {
+    return NS_ERROR_FAILURE;
+  }
+
+  const uint8_t* src = reinterpret_cast<const uint8_t*>(aBuf);
+  uint32_t bytesToCopy = FramesToBytes(aFrames);
+
+  // XXX this will need to change if we want to enable this on-the-fly!
+  if (PR_LOG_TEST(GetLatencyLog(), PR_LOG_DEBUG)) {
+    // Record the position and time this data was inserted
+    int64_t timeMs;
+    if (aTime && !aTime->IsNull()) {
+      if (mStartTime.IsNull()) {
+        AsyncLatencyLogger::Get(true)->GetStartTime(mStartTime);
+      }
+      timeMs = (*aTime - mStartTime).ToMilliseconds();
+    } else {
+      timeMs = 0;
+    }
+    struct Inserts insert = { timeMs, aFrames};
+    mInserts.AppendElement(insert);
+  }
+
+  while (bytesToCopy > 0) {
+    uint32_t available = std::min(bytesToCopy, mBuffer.Available());
+    NS_ABORT_IF_FALSE(available % mBytesPerFrame == 0,
+        "Must copy complete frames.");
+
+    mBuffer.AppendElements(src, available);
+    src += available;
+    bytesToCopy -= available;
+
+    if (bytesToCopy > 0) {
+      // Careful - the CubebInit thread may not have gotten to STARTED yet
+      if ((mState == INITIALIZED || mState == STARTED) && mLatencyRequest == LowLatency) {
+        // don't ever block MediaStreamGraph low-latency streams
+        uint32_t remains = 0; // we presume the buffer is full
+        if (mBuffer.Length() > bytesToCopy) {
+          remains = mBuffer.Length() - bytesToCopy; // Free up just enough space
+        }
+        // account for dropping samples
+        PR_LOG(gAudioStreamLog, PR_LOG_WARNING, ("Stream %p dropping %u bytes (%u frames)in Write()",
+            this, mBuffer.Length() - remains, BytesToFrames(mBuffer.Length() - remains)));
+        mReadPoint += BytesToFrames(mBuffer.Length() - remains);
+        mBuffer.ContractTo(remains);
+      } else { // RUNNING or high latency
+        // If we are not playing, but our buffer is full, start playing to make
+        // room for soon-to-be-decoded data.
+        if (mState != STARTED && mState != RUNNING) {
+          PR_LOG(gAudioStreamLog, PR_LOG_WARNING, ("Starting stream %p in Write (%u waiting)",
+                                                 this, bytesToCopy));
+          StartUnlocked();
+          if (mState == ERRORED) {
+            return NS_ERROR_FAILURE;
+          }
+        }
+        PR_LOG(gAudioStreamLog, PR_LOG_WARNING, ("Stream %p waiting in Write() (%u waiting)",
+                                                 this, bytesToCopy));
+        mon.Wait();
+      }
+    }
+  }
+
+  mWritten += aFrames;
+  return NS_OK;
+}
+
+uint32_t
+AudioStream::Available()
+{
+  MonitorAutoLock mon(mMonitor);
+  NS_ABORT_IF_FALSE(mBuffer.Length() % mBytesPerFrame == 0, "Buffer invariant violated.");
+  return BytesToFrames(mBuffer.Available());
+}
+
+void
+AudioStream::SetVolume(double aVolume)
+{
+  MonitorAutoLock mon(mMonitor);
+  NS_ABORT_IF_FALSE(aVolume >= 0.0 && aVolume <= 1.0, "Invalid volume");
+  mVolume = aVolume;
+}
+
+void
+AudioStream::Drain()
+{
+  MonitorAutoLock mon(mMonitor);
+  LOG(("AudioStream::Drain() for %p, state %d, avail %u", this, mState, mBuffer.Available()));
+  if (mState != STARTED && mState != RUNNING) {
+    NS_ASSERTION(mState == ERRORED || mBuffer.Available() == 0, "Draining without full buffer of unplayed audio");
+    return;
+  }
+  mState = DRAINING;
+  while (mState == DRAINING) {
+    mon.Wait();
+  }
+}
+
+void
+AudioStream::Start()
+{
+  MonitorAutoLock mon(mMonitor);
+  StartUnlocked();
+}
+
+void
+AudioStream::StartUnlocked()
+{
+  mMonitor.AssertCurrentThreadOwns();
+  if (!mCubebStream) {
+    mNeedsStart = true;
+    return;
+  }
+  MonitorAutoUnlock mon(mMonitor);
+  if (mState == INITIALIZED) {
+    int r = cubeb_stream_start(mCubebStream);
+    mState = r == CUBEB_OK ? STARTED : ERRORED;
+    LOG(("AudioStream: started %p, state %s", this, mState == STARTED ? "STARTED" : "ERRORED"));
+  }
+}
+
+void
+AudioStream::Pause()
+{
+  MonitorAutoLock mon(mMonitor);
+  if (!mCubebStream || (mState != STARTED && mState != RUNNING)) {
+    mNeedsStart = false;
+    mState = STOPPED; // which also tells async OpenCubeb not to start, just init
+    return;
+  }
+
+  int r;
+  {
+    MonitorAutoUnlock mon(mMonitor);
+    r = cubeb_stream_stop(mCubebStream);
+  }
+  if (mState != ERRORED && r == CUBEB_OK) {
+    mState = STOPPED;
+  }
+}
+
+void
+AudioStream::Resume()
+{
+  MonitorAutoLock mon(mMonitor);
+  if (!mCubebStream || mState != STOPPED) {
+    return;
+  }
+
+  int r;
+  {
+    MonitorAutoUnlock mon(mMonitor);
+    r = cubeb_stream_start(mCubebStream);
+  }
+  if (mState != ERRORED && r == CUBEB_OK) {
+    mState = STARTED;
+  }
+}
+
+void
+AudioStream::Shutdown()
+{
+  LOG(("AudioStream: Shutdown %p, state %d", this, mState));
+  {
+    MonitorAutoLock mon(mMonitor);
+    if (mState == STARTED || mState == RUNNING) {
+      MonitorAutoUnlock mon(mMonitor);
+      Pause();
+    }
+    MOZ_ASSERT(mState != STARTED && mState != RUNNING); // paranoia
+    mState = SHUTDOWN;
+  }
+  // Must not try to shut down cubeb from within the lock!  wasapi may still
+  // call our callback after Pause()/stop()!?! Bug 996162
+  if (mCubebStream) {
+    mCubebStream.reset();
+  }
+}
+
+int64_t
+AudioStream::GetPosition()
+{
+  MonitorAutoLock mon(mMonitor);
+  return mAudioClock.GetPositionUnlocked();
+}
+
+// This function is miscompiled by PGO with MSVC 2010.  See bug 768333.
+#ifdef _MSC_VER
+#pragma optimize("", off)
+#endif
+int64_t
+AudioStream::GetPositionInFrames()
+{
+  return mAudioClock.GetPositionInFrames();
+}
+#ifdef _MSC_VER
+#pragma optimize("", on)
+#endif
+
+int64_t
+AudioStream::GetPositionInFramesInternal()
+{
+  MonitorAutoLock mon(mMonitor);
+  return GetPositionInFramesUnlocked();
+}
+
+int64_t
+AudioStream::GetPositionInFramesUnlocked()
+{
+  mMonitor.AssertCurrentThreadOwns();
+
+  if (!mCubebStream || mState == ERRORED) {
+    return -1;
+  }
+
+  uint64_t position = 0;
+  {
+    MonitorAutoUnlock mon(mMonitor);
+    if (cubeb_stream_get_position(mCubebStream, &position) != CUBEB_OK) {
+      return -1;
+    }
+  }
+
+  // Adjust the reported position by the number of silent frames written
+  // during stream underruns.
+  uint64_t adjustedPosition = 0;
+  if (position >= mLostFrames) {
+    adjustedPosition = position - mLostFrames;
+  }
+  return std::min<uint64_t>(adjustedPosition, INT64_MAX);
+}
+
+int64_t
+AudioStream::GetLatencyInFrames()
+{
+  uint32_t latency;
+  if (cubeb_stream_get_latency(mCubebStream, &latency)) {
+    NS_WARNING("Could not get cubeb latency.");
+    return 0;
+  }
+  return static_cast<int64_t>(latency);
+}
+
+bool
+AudioStream::IsPaused()
+{
+  MonitorAutoLock mon(mMonitor);
+  return mState == STOPPED;
+}
+
+void
+AudioStream::GetBufferInsertTime(int64_t &aTimeMs)
+{
+  if (mInserts.Length() > 0) {
+    // Find the right block, but don't leave the array empty
+    while (mInserts.Length() > 1 && mReadPoint >= mInserts[0].mFrames) {
+      mReadPoint -= mInserts[0].mFrames;
+      mInserts.RemoveElementAt(0);
+    }
+    // offset for amount already read
+    // XXX Note: could misreport if we couldn't find a block in the right timeframe
+    aTimeMs = mInserts[0].mTimeMs + ((mReadPoint * 1000) / mOutRate);
+  } else {
+    aTimeMs = INT64_MAX;
+  }
+}
+
+long
+AudioStream::GetUnprocessed(void* aBuffer, long aFrames, int64_t &aTimeMs)
+{
+  uint8_t* wpos = reinterpret_cast<uint8_t*>(aBuffer);
+
+  // Flush the timestretcher pipeline, if we were playing using a playback rate
+  // other than 1.0.
+  uint32_t flushedFrames = 0;
+  if (mTimeStretcher && mTimeStretcher->numSamples()) {
+    flushedFrames = mTimeStretcher->receiveSamples(reinterpret_cast<AudioDataValue*>(wpos), aFrames);
+    wpos += FramesToBytes(flushedFrames);
+  }
+  uint32_t toPopBytes = FramesToBytes(aFrames - flushedFrames);
+  uint32_t available = std::min(toPopBytes, mBuffer.Length());
+
+  void* input[2];
+  uint32_t input_size[2];
+  mBuffer.PopElements(available, &input[0], &input_size[0], &input[1], &input_size[1]);
+  memcpy(wpos, input[0], input_size[0]);
+  wpos += input_size[0];
+  memcpy(wpos, input[1], input_size[1]);
+
+  // First time block now has our first returned sample
+  mReadPoint += BytesToFrames(available);
+  GetBufferInsertTime(aTimeMs);
+
+  return BytesToFrames(available) + flushedFrames;
+}
+
+// Get unprocessed samples, and pad the beginning of the buffer with silence if
+// there is not enough data.
+long
+AudioStream::GetUnprocessedWithSilencePadding(void* aBuffer, long aFrames, int64_t& aTimeMs)
+{
+  uint32_t toPopBytes = FramesToBytes(aFrames);
+  uint32_t available = std::min(toPopBytes, mBuffer.Length());
+  uint32_t silenceOffset = toPopBytes - available;
+
+  uint8_t* wpos = reinterpret_cast<uint8_t*>(aBuffer);
+
+  memset(wpos, 0, silenceOffset);
+  wpos += silenceOffset;
+
+  void* input[2];
+  uint32_t input_size[2];
+  mBuffer.PopElements(available, &input[0], &input_size[0], &input[1], &input_size[1]);
+  memcpy(wpos, input[0], input_size[0]);
+  wpos += input_size[0];
+  memcpy(wpos, input[1], input_size[1]);
+
+  GetBufferInsertTime(aTimeMs);
+
+  return aFrames;
+}
+
+long
+AudioStream::GetTimeStretched(void* aBuffer, long aFrames, int64_t &aTimeMs)
+{
+  long processedFrames = 0;
+
+  // We need to call the non-locking version, because we already have the lock.
+  if (EnsureTimeStretcherInitializedUnlocked() != NS_OK) {
+    return 0;
+  }
+
+  uint8_t* wpos = reinterpret_cast<uint8_t*>(aBuffer);
+  double playbackRate = static_cast<double>(mInRate) / mOutRate;
+  uint32_t toPopBytes = FramesToBytes(ceil(aFrames / playbackRate));
+  uint32_t available = 0;
+  bool lowOnBufferedData = false;
+  do {
+    // Check if we already have enough data in the time stretcher pipeline.
+    if (mTimeStretcher->numSamples() <= static_cast<uint32_t>(aFrames)) {
+      void* input[2];
+      uint32_t input_size[2];
+      available = std::min(mBuffer.Length(), toPopBytes);
+      if (available != toPopBytes) {
+        lowOnBufferedData = true;
+      }
+      mBuffer.PopElements(available, &input[0], &input_size[0],
+                                     &input[1], &input_size[1]);
+      mReadPoint += BytesToFrames(available);
+      for(uint32_t i = 0; i < 2; i++) {
+        mTimeStretcher->putSamples(reinterpret_cast<AudioDataValue*>(input[i]), BytesToFrames(input_size[i]));
+      }
+    }
+    uint32_t receivedFrames = mTimeStretcher->receiveSamples(reinterpret_cast<AudioDataValue*>(wpos), aFrames - processedFrames);
+    wpos += FramesToBytes(receivedFrames);
+    processedFrames += receivedFrames;
+  } while (processedFrames < aFrames && !lowOnBufferedData);
+
+  GetBufferInsertTime(aTimeMs);
+
+  return processedFrames;
+}
+
+long
+AudioStream::DataCallback(void* aBuffer, long aFrames)
+{
+  MonitorAutoLock mon(mMonitor);
+  uint32_t available = std::min(static_cast<uint32_t>(FramesToBytes(aFrames)), mBuffer.Length());
+  NS_ABORT_IF_FALSE(available % mBytesPerFrame == 0, "Must copy complete frames");
+  AudioDataValue* output = reinterpret_cast<AudioDataValue*>(aBuffer);
+  uint32_t underrunFrames = 0;
+  uint32_t servicedFrames = 0;
+  int64_t insertTime;
+
+  // NOTE: wasapi (others?) can call us back *after* stop()/Shutdown() (mState == SHUTDOWN)
+  // Bug 996162
+
+  // callback tells us cubeb succeeded initializing
+  if (mState == STARTED) {
+    // For low-latency streams, we want to minimize any built-up data when
+    // we start getting callbacks.
+    // Simple version - contract on first callback only.
+    if (mLatencyRequest == LowLatency) {
+#ifdef PR_LOGGING
+      uint32_t old_len = mBuffer.Length();
+#endif
+      available = mBuffer.ContractTo(FramesToBytes(aFrames));
+#ifdef PR_LOGGING
+      TimeStamp now = TimeStamp::Now();
+      if (!mStartTime.IsNull()) {
+        int64_t timeMs = (now - mStartTime).ToMilliseconds();
+        PR_LOG(gAudioStreamLog, PR_LOG_WARNING,
+               ("Stream took %lldms to start after first Write() @ %u", timeMs, mOutRate));
+      } else {
+        PR_LOG(gAudioStreamLog, PR_LOG_WARNING,
+          ("Stream started before Write() @ %u", mOutRate));
+      }
+
+      if (old_len != available) {
+        // Note that we may have dropped samples in Write() as well!
+        PR_LOG(gAudioStreamLog, PR_LOG_WARNING,
+               ("AudioStream %p dropped %u + %u initial frames @ %u", this,
+                 mReadPoint, BytesToFrames(old_len - available), mOutRate));
+        mReadPoint += BytesToFrames(old_len - available);
+      }
+#endif
+    }
+    mState = RUNNING;
+  }
+
+  if (available) {
+    // When we are playing a low latency stream, and it is the first time we are
+    // getting data from the buffer, we prefer to add the silence for an
+    // underrun at the beginning of the buffer, so the first buffer is not cut
+    // in half by the silence inserted to compensate for the underrun.
+    if (mInRate == mOutRate) {
+      if (mLatencyRequest == LowLatency && !mWritten) {
+        servicedFrames = GetUnprocessedWithSilencePadding(output, aFrames, insertTime);
+      } else {
+        servicedFrames = GetUnprocessed(output, aFrames, insertTime);
+      }
+    } else {
+      servicedFrames = GetTimeStretched(output, aFrames, insertTime);
+    }
+    float scaled_volume = float(GetVolumeScale() * mVolume);
+
+    ScaleAudioSamples(output, aFrames * mOutChannels, scaled_volume);
+
+    NS_ABORT_IF_FALSE(mBuffer.Length() % mBytesPerFrame == 0, "Must copy complete frames");
+
+    // Notify any blocked Write() call that more space is available in mBuffer.
+    mon.NotifyAll();
+  } else {
+    GetBufferInsertTime(insertTime);
+  }
+
+  underrunFrames = aFrames - servicedFrames;
+
+  if (mState != DRAINING) {
+    uint8_t* rpos = static_cast<uint8_t*>(aBuffer) + FramesToBytes(aFrames - underrunFrames);
+    memset(rpos, 0, FramesToBytes(underrunFrames));
+    if (underrunFrames) {
+      PR_LOG(gAudioStreamLog, PR_LOG_WARNING,
+             ("AudioStream %p lost %d frames", this, underrunFrames));
+    }
+    mLostFrames += underrunFrames;
+    servicedFrames += underrunFrames;
+  }
+
+  WriteDumpFile(mDumpFile, this, aFrames, aBuffer);
+  // Don't log if we're not interested or if the stream is inactive
+  if (PR_LOG_TEST(GetLatencyLog(), PR_LOG_DEBUG) &&
+      mState != SHUTDOWN &&
+      insertTime != INT64_MAX && servicedFrames > underrunFrames) {
+    uint32_t latency = UINT32_MAX;
+    if (cubeb_stream_get_latency(mCubebStream, &latency)) {
+      NS_WARNING("Could not get latency from cubeb.");
+    }
+    TimeStamp now = TimeStamp::Now();
+
+    mLatencyLog->Log(AsyncLatencyLogger::AudioStream, reinterpret_cast<uint64_t>(this),
+                     insertTime, now);
+    mLatencyLog->Log(AsyncLatencyLogger::Cubeb, reinterpret_cast<uint64_t>(mCubebStream.get()),
+                     (latency * 1000) / mOutRate, now);
+  }
+
+  mAudioClock.UpdateWritePosition(servicedFrames);
+  return servicedFrames;
+}
+
+void
+AudioStream::StateCallback(cubeb_state aState)
+{
+  MonitorAutoLock mon(mMonitor);
+  if (aState == CUBEB_STATE_DRAINED) {
+    mState = DRAINED;
+  } else if (aState == CUBEB_STATE_ERROR) {
+    LOG(("AudioStream::StateCallback() state %d cubeb error", mState));
+    mState = ERRORED;
+  }
+  mon.NotifyAll();
+}
+
+AudioClock::AudioClock(AudioStream* aStream)
+ :mAudioStream(aStream),
+  mOldOutRate(0),
+  mBasePosition(0),
+  mBaseOffset(0),
+  mOldBaseOffset(0),
+  mOldBasePosition(0),
+  mPlaybackRateChangeOffset(0),
+  mPreviousPosition(0),
+  mWritten(0),
+  mOutRate(0),
+  mInRate(0),
+  mPreservesPitch(true),
+  mCompensatingLatency(false)
+{}
+
+void AudioClock::Init()
+{
+  mOutRate = mAudioStream->GetRate();
+  mInRate = mAudioStream->GetRate();
+  mOldOutRate = mOutRate;
+}
+
+void AudioClock::UpdateWritePosition(uint32_t aCount)
+{
+  mWritten += aCount;
+}
+
+uint64_t AudioClock::GetPositionUnlocked()
+{
+  // GetPositionInFramesUnlocked() asserts it owns the monitor
+  int64_t position = mAudioStream->GetPositionInFramesUnlocked();
+  int64_t diffOffset;
+  NS_ASSERTION(position < 0 || (mInRate != 0 && mOutRate != 0), "AudioClock not initialized.");
+  if (position >= 0) {
+    if (position < mPlaybackRateChangeOffset) {
+      // See if we are still playing frames pushed with the old playback rate in
+      // the backend. If we are, use the old output rate to compute the
+      // position.
+      mCompensatingLatency = true;
+      diffOffset = position - mOldBaseOffset;
+      position = static_cast<uint64_t>(mOldBasePosition +
+        static_cast<float>(USECS_PER_S * diffOffset) / mOldOutRate);
+      mPreviousPosition = position;
+      return position;
+    }
+
+    if (mCompensatingLatency) {
+      diffOffset = position - mPlaybackRateChangeOffset;
+      mCompensatingLatency = false;
+      mBasePosition = mPreviousPosition;
+    } else {
+      diffOffset = position - mPlaybackRateChangeOffset;
+    }
+    position =  static_cast<uint64_t>(mBasePosition +
+      (static_cast<float>(USECS_PER_S * diffOffset) / mOutRate));
+    return position;
+  }
+  return UINT64_MAX;
+}
+
+uint64_t AudioClock::GetPositionInFrames()
+{
+  return (GetPositionUnlocked() * mOutRate) / USECS_PER_S;
+}
+
+void AudioClock::SetPlaybackRateUnlocked(double aPlaybackRate)
+{
+  // GetPositionInFramesUnlocked() asserts it owns the monitor
+  int64_t position = mAudioStream->GetPositionInFramesUnlocked();
+  if (position > mPlaybackRateChangeOffset) {
+    mOldBasePosition = mBasePosition;
+    mBasePosition = GetPositionUnlocked();
+    mOldBaseOffset = mPlaybackRateChangeOffset;
+    mBaseOffset = position;
+    mPlaybackRateChangeOffset = mWritten;
+    mOldOutRate = mOutRate;
+    mOutRate = static_cast<int>(mInRate / aPlaybackRate);
+  } else {
+    // The playbackRate has been changed before the end of the latency
+    // compensation phase. We don't update the mOld* variable. That way, the
+    // last playbackRate set is taken into account.
+    mBasePosition = GetPositionUnlocked();
+    mBaseOffset = position;
+    mPlaybackRateChangeOffset = mWritten;
+    mOutRate = static_cast<int>(mInRate / aPlaybackRate);
+  }
+}
+
+double AudioClock::GetPlaybackRate()
+{
+  return static_cast<double>(mInRate) / mOutRate;
+}
+
+void AudioClock::SetPreservesPitch(bool aPreservesPitch)
+{
+  mPreservesPitch = aPreservesPitch;
+}
+
+bool AudioClock::GetPreservesPitch()
+{
+  return mPreservesPitch;
+}
+} // namespace mozilla