Add m-esr52 at 52.6.0

1 files changed, 386 insertions, 0 deletions

diff --git a/dom/media/CubebUtils.cpp b/dom/media/CubebUtils.cpp
new file mode 100644
index 000000000..d1b4bae99
--- /dev/null
+++ b/dom/media/CubebUtils.cpp
@@ -0,0 +1,386 @@
+/* -*- 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 <stdint.h>
+#include <algorithm>
+#include "nsIStringBundle.h"
+#include "nsDebug.h"
+#include "nsString.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/StaticMutex.h"
+#include "mozilla/StaticPtr.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/Logging.h"
+#include "nsThreadUtils.h"
+#include "CubebUtils.h"
+#include "nsAutoRef.h"
+#include "prdtoa.h"
+
+#define PREF_VOLUME_SCALE "media.volume_scale"
+#define PREF_CUBEB_LATENCY_PLAYBACK "media.cubeb_latency_playback_ms"
+#define PREF_CUBEB_LATENCY_MSG "media.cubeb_latency_msg_frames"
+
+namespace mozilla {
+
+namespace {
+
+LazyLogModule gCubebLog("cubeb");
+
+void CubebLogCallback(const char* aFmt, ...)
+{
+  char buffer[256];
+
+  va_list arglist;
+  va_start(arglist, aFmt);
+  VsprintfLiteral (buffer, aFmt, arglist);
+  MOZ_LOG(gCubebLog, LogLevel::Error, ("%s", buffer));
+  va_end(arglist);
+}
+
+// This mutex protects the variables below.
+StaticMutex sMutex;
+enum class CubebState {
+  Uninitialized = 0,
+  Initialized,
+  Shutdown
+} sCubebState = CubebState::Uninitialized;
+cubeb* sCubebContext;
+double sVolumeScale;
+uint32_t sCubebPlaybackLatencyInMilliseconds;
+uint32_t sCubebMSGLatencyInFrames;
+bool sCubebPlaybackLatencyPrefSet;
+bool sCubebMSGLatencyPrefSet;
+bool sAudioStreamInitEverSucceeded = false;
+StaticAutoPtr<char> sBrandName;
+
+const char kBrandBundleURL[]      = "chrome://branding/locale/brand.properties";
+
+const char* AUDIOSTREAM_BACKEND_ID_STR[] = {
+  "jack",
+  "pulse",
+  "alsa",
+  "audiounit",
+  "audioqueue",
+  "wasapi",
+  "winmm",
+  "directsound",
+  "sndio",
+  "opensl",
+  "audiotrack",
+  "kai"
+};
+/* Index for failures to create an audio stream the first time. */
+const int CUBEB_BACKEND_INIT_FAILURE_FIRST =
+  ArrayLength(AUDIOSTREAM_BACKEND_ID_STR);
+/* Index for failures to create an audio stream after the first time */
+const int CUBEB_BACKEND_INIT_FAILURE_OTHER = CUBEB_BACKEND_INIT_FAILURE_FIRST + 1;
+/* Index for an unknown backend. */
+const int CUBEB_BACKEND_UNKNOWN = CUBEB_BACKEND_INIT_FAILURE_FIRST + 2;
+
+
+// Prefered samplerate, in Hz (characteristic of the hardware, mixer, platform,
+// and API used).
+//
+// sMutex protects *initialization* of this, which must be performed from each
+// thread before fetching, after which it is safe to fetch without holding the
+// mutex because it is only written once per process execution (by the first
+// initialization to complete).  Since the init must have been called on a
+// given thread before fetching the value, it's guaranteed (via the mutex) that
+// sufficient memory barriers have occurred to ensure the correct value is
+// visible on the querying thread/CPU.
+uint32_t sPreferredSampleRate;
+
+} // namespace
+
+extern LazyLogModule gAudioStreamLog;
+
+static const uint32_t CUBEB_NORMAL_LATENCY_MS = 100;
+// Consevative default that can work on all platforms.
+static const uint32_t CUBEB_NORMAL_LATENCY_FRAMES = 1024;
+
+namespace CubebUtils {
+
+void 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_PLAYBACK) == 0) {
+    // Arbitrary default stream latency of 100ms.  The higher this
+    // value, the longer stream volume changes will take to become
+    // audible.
+    sCubebPlaybackLatencyPrefSet = Preferences::HasUserValue(aPref);
+    uint32_t value = Preferences::GetUint(aPref, CUBEB_NORMAL_LATENCY_MS);
+    StaticMutexAutoLock lock(sMutex);
+    sCubebPlaybackLatencyInMilliseconds = std::min<uint32_t>(std::max<uint32_t>(value, 1), 1000);
+  } else if (strcmp(aPref, PREF_CUBEB_LATENCY_MSG) == 0) {
+    sCubebMSGLatencyPrefSet = Preferences::HasUserValue(aPref);
+    uint32_t value = Preferences::GetUint(aPref, CUBEB_NORMAL_LATENCY_FRAMES);
+    StaticMutexAutoLock lock(sMutex);
+    // 128 is the block size for the Web Audio API, which limits how low the
+    // latency can be here.
+    // We don't want to limit the upper limit too much, so that people can
+    // experiment.
+    sCubebMSGLatencyInFrames = std::min<uint32_t>(std::max<uint32_t>(value, 128), 1e6);
+  }
+}
+
+bool GetFirstStream()
+{
+  static bool sFirstStream = true;
+
+  StaticMutexAutoLock lock(sMutex);
+  bool result = sFirstStream;
+  sFirstStream = false;
+  return result;
+}
+
+double GetVolumeScale()
+{
+  StaticMutexAutoLock lock(sMutex);
+  return sVolumeScale;
+}
+
+cubeb* GetCubebContext()
+{
+  StaticMutexAutoLock lock(sMutex);
+  return GetCubebContextUnlocked();
+}
+
+bool InitPreferredSampleRate()
+{
+  StaticMutexAutoLock lock(sMutex);
+  if (sPreferredSampleRate != 0) {
+    return true;
+  }
+  cubeb* context = GetCubebContextUnlocked();
+  if (!context) {
+    return false;
+  }
+  if (cubeb_get_preferred_sample_rate(context,
+                                      &sPreferredSampleRate) != CUBEB_OK) {
+
+    return false;
+  }
+  MOZ_ASSERT(sPreferredSampleRate);
+  return true;
+}
+
+uint32_t PreferredSampleRate()
+{
+  if (!InitPreferredSampleRate()) {
+    return 44100;
+  }
+  MOZ_ASSERT(sPreferredSampleRate);
+  return sPreferredSampleRate;
+}
+
+void InitBrandName()
+{
+  if (sBrandName) {
+    return;
+  }
+  nsXPIDLString brandName;
+  nsCOMPtr<nsIStringBundleService> stringBundleService =
+    mozilla::services::GetStringBundleService();
+  if (stringBundleService) {
+    nsCOMPtr<nsIStringBundle> brandBundle;
+    nsresult rv = stringBundleService->CreateBundle(kBrandBundleURL,
+                                           getter_AddRefs(brandBundle));
+    if (NS_SUCCEEDED(rv)) {
+      rv = brandBundle->GetStringFromName(u"brandShortName",
+                                          getter_Copies(brandName));
+      NS_WARNING_ASSERTION(
+        NS_SUCCEEDED(rv), "Could not get the program name for a cubeb stream.");
+    }
+  }
+  /* cubeb expects a c-string. */
+  const char* ascii = NS_LossyConvertUTF16toASCII(brandName).get();
+  sBrandName = new char[brandName.Length() + 1];
+  PodCopy(sBrandName.get(), ascii, brandName.Length());
+  sBrandName[brandName.Length()] = 0;
+}
+
+cubeb* GetCubebContextUnlocked()
+{
+  sMutex.AssertCurrentThreadOwns();
+  if (sCubebState != CubebState::Uninitialized) {
+    // If we have already passed the initialization point (below), just return
+    // the current context, which may be null (e.g., after error or shutdown.)
+    return sCubebContext;
+  }
+
+  if (!sBrandName && NS_IsMainThread()) {
+    InitBrandName();
+  } else {
+    NS_WARNING_ASSERTION(
+      sBrandName, "Did not initialize sbrandName, and not on the main thread?");
+  }
+
+  int rv = cubeb_init(&sCubebContext, sBrandName);
+  NS_WARNING_ASSERTION(rv == CUBEB_OK, "Could not get a cubeb context.");
+  sCubebState = (rv == CUBEB_OK) ? CubebState::Initialized : CubebState::Uninitialized;
+
+  if (MOZ_LOG_TEST(gCubebLog, LogLevel::Verbose)) {
+    cubeb_set_log_callback(CUBEB_LOG_VERBOSE, CubebLogCallback);
+  } else if (MOZ_LOG_TEST(gCubebLog, LogLevel::Error)) {
+    cubeb_set_log_callback(CUBEB_LOG_NORMAL, CubebLogCallback);
+  }
+
+  return sCubebContext;
+}
+
+void ReportCubebBackendUsed()
+{
+  StaticMutexAutoLock lock(sMutex);
+
+  sAudioStreamInitEverSucceeded = true;
+
+  bool foundBackend = false;
+  for (uint32_t i = 0; i < ArrayLength(AUDIOSTREAM_BACKEND_ID_STR); i++) {
+    if (!strcmp(cubeb_get_backend_id(sCubebContext), AUDIOSTREAM_BACKEND_ID_STR[i])) {
+      Telemetry::Accumulate(Telemetry::AUDIOSTREAM_BACKEND_USED, i);
+      foundBackend = true;
+    }
+  }
+  if (!foundBackend) {
+    Telemetry::Accumulate(Telemetry::AUDIOSTREAM_BACKEND_USED,
+                          CUBEB_BACKEND_UNKNOWN);
+  }
+}
+
+void ReportCubebStreamInitFailure(bool aIsFirst)
+{
+  StaticMutexAutoLock lock(sMutex);
+  if (!aIsFirst && !sAudioStreamInitEverSucceeded) {
+    // This machine has no audio hardware, or it's in really bad shape, don't
+    // send this info, since we want CUBEB_BACKEND_INIT_FAILURE_OTHER to detect
+    // failures to open multiple streams in a process over time.
+    return;
+  }
+  Telemetry::Accumulate(Telemetry::AUDIOSTREAM_BACKEND_USED,
+                        aIsFirst ? CUBEB_BACKEND_INIT_FAILURE_FIRST
+                                 : CUBEB_BACKEND_INIT_FAILURE_OTHER);
+}
+
+uint32_t GetCubebPlaybackLatencyInMilliseconds()
+{
+  StaticMutexAutoLock lock(sMutex);
+  return sCubebPlaybackLatencyInMilliseconds;
+}
+
+bool CubebPlaybackLatencyPrefSet()
+{
+  StaticMutexAutoLock lock(sMutex);
+  return sCubebPlaybackLatencyPrefSet;
+}
+
+bool CubebMSGLatencyPrefSet()
+{
+  StaticMutexAutoLock lock(sMutex);
+  return sCubebMSGLatencyPrefSet;
+}
+
+Maybe<uint32_t> GetCubebMSGLatencyInFrames()
+{
+  StaticMutexAutoLock lock(sMutex);
+  if (!sCubebMSGLatencyPrefSet) {
+    return Maybe<uint32_t>();
+  }
+  MOZ_ASSERT(sCubebMSGLatencyInFrames > 0);
+  return Some(sCubebMSGLatencyInFrames);
+}
+
+void InitLibrary()
+{
+  PrefChanged(PREF_VOLUME_SCALE, nullptr);
+  Preferences::RegisterCallback(PrefChanged, PREF_VOLUME_SCALE);
+  PrefChanged(PREF_CUBEB_LATENCY_PLAYBACK, nullptr);
+  PrefChanged(PREF_CUBEB_LATENCY_MSG, nullptr);
+  Preferences::RegisterCallback(PrefChanged, PREF_CUBEB_LATENCY_PLAYBACK);
+  Preferences::RegisterCallback(PrefChanged, PREF_CUBEB_LATENCY_MSG);
+#ifndef MOZ_WIDGET_ANDROID
+  NS_DispatchToMainThread(NS_NewRunnableFunction(&InitBrandName));
+#endif
+}
+
+void ShutdownLibrary()
+{
+  Preferences::UnregisterCallback(PrefChanged, PREF_VOLUME_SCALE);
+  Preferences::UnregisterCallback(PrefChanged, PREF_CUBEB_LATENCY_PLAYBACK);
+  Preferences::UnregisterCallback(PrefChanged, PREF_CUBEB_LATENCY_MSG);
+
+  StaticMutexAutoLock lock(sMutex);
+  if (sCubebContext) {
+    cubeb_destroy(sCubebContext);
+    sCubebContext = nullptr;
+  }
+  sBrandName = nullptr;
+  // This will ensure we don't try to re-create a context.
+  sCubebState = CubebState::Shutdown;
+}
+
+uint32_t MaxNumberOfChannels()
+{
+  cubeb* cubebContext = GetCubebContext();
+  uint32_t maxNumberOfChannels;
+  if (cubebContext &&
+      cubeb_get_max_channel_count(cubebContext,
+                                  &maxNumberOfChannels) == CUBEB_OK) {
+    return maxNumberOfChannels;
+  }
+
+  return 0;
+}
+
+#if defined(__ANDROID__) && defined(MOZ_B2G)
+cubeb_stream_type ConvertChannelToCubebType(dom::AudioChannel aChannel)
+{
+  switch(aChannel) {
+    case dom::AudioChannel::Normal:
+      /* FALLTHROUGH */
+    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;
+    case dom::AudioChannel::System:
+      return CUBEB_STREAM_TYPE_SYSTEM;
+    case dom::AudioChannel::Publicnotification:
+      return CUBEB_STREAM_TYPE_SYSTEM_ENFORCED;
+    default:
+      NS_ERROR("The value of AudioChannel is invalid");
+      return CUBEB_STREAM_TYPE_MAX;
+  }
+}
+#endif
+
+void GetCurrentBackend(nsAString& aBackend)
+{
+  cubeb* cubebContext = GetCubebContext();
+  if (cubebContext) {
+    const char* backend = cubeb_get_backend_id(cubebContext);
+    if (backend) {
+      aBackend.AssignASCII(backend);
+      return;
+    }
+  }
+  aBackend.AssignLiteral("unknown");
+}
+
+} // namespace CubebUtils
+} // namespace mozilla