--- a/dom/media/MP3Decoder.cpp
+++ b/dom/media/MP3Decoder.cpp
@@ -4,17 +4,16 @@
/* 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 "MP3Decoder.h"
#include "MediaDecoderStateMachine.h"
#include "MediaFormatReader.h"
#include "MP3Demuxer.h"
-#include "mozilla/Preferences.h"
#include "PDMFactory.h"
namespace mozilla {
MediaDecoder*
MP3Decoder::Clone(MediaDecoderOwner* aOwner) {
if (!IsEnabled()) {
return nullptr;
--- a/dom/media/MediaFormatReader.cpp
+++ b/dom/media/MediaFormatReader.cpp
@@ -163,37 +163,29 @@ MediaFormatReader::InitLayersBackendType
RefPtr<LayerManager> layerManager =
nsContentUtils::LayerManagerForDocument(element->OwnerDoc());
NS_ENSURE_TRUE_VOID(layerManager);
mLayersBackendType = layerManager->GetCompositorBackendType();
}
-static bool sIsEMEEnabled = false;
-
nsresult
MediaFormatReader::Init()
{
MOZ_ASSERT(NS_IsMainThread(), "Must be on main thread.");
PDMFactory::Init();
InitLayersBackendType();
mAudio.mTaskQueue =
new FlushableTaskQueue(GetMediaThreadPool(MediaThreadType::PLATFORM_DECODER));
mVideo.mTaskQueue =
new FlushableTaskQueue(GetMediaThreadPool(MediaThreadType::PLATFORM_DECODER));
- static bool sSetupPrefCache = false;
- if (!sSetupPrefCache) {
- sSetupPrefCache = true;
- Preferences::AddBoolVarCache(&sIsEMEEnabled, "media.eme.enabled", false);
- }
-
return NS_OK;
}
#ifdef MOZ_EME
class DispatchKeyNeededEvent : public Runnable {
public:
DispatchKeyNeededEvent(AbstractMediaDecoder* aDecoder,
nsTArray<uint8_t>& aInitData,
--- a/dom/media/MediaManager.cpp
+++ b/dom/media/MediaManager.cpp
@@ -38,17 +38,16 @@
#include "mozilla/Types.h"
#include "mozilla/PeerIdentity.h"
#include "mozilla/dom/ContentChild.h"
#include "mozilla/dom/File.h"
#include "mozilla/dom/MediaStreamBinding.h"
#include "mozilla/dom/MediaStreamTrackBinding.h"
#include "mozilla/dom/GetUserMediaRequestBinding.h"
#include "mozilla/dom/Promise.h"
-#include "mozilla/Preferences.h"
#include "mozilla/Base64.h"
#include "mozilla/ipc/BackgroundChild.h"
#include "mozilla/media/MediaChild.h"
#include "MediaTrackConstraints.h"
#include "VideoUtils.h"
#include "Latency.h"
#include "nsProxyRelease.h"
#include "nsNullPrincipal.h"
--- a/dom/media/MediaPrefs.h
+++ b/dom/media/MediaPrefs.h
@@ -27,16 +27,20 @@
#define DECL_MEDIA_PREF(Pref, Name, Type, Default) \
public: \
static const Type& Name() { MOZ_ASSERT(SingletonExists()); return GetSingleton().mPref##Name.mValue; } \
private: \
static const char* Get##Name##PrefName() { return Pref; } \
static Type Get##Name##PrefDefault() { return Default; } \
PrefTemplate<Type, Get##Name##PrefDefault, Get##Name##PrefName> mPref##Name
+// Custom Definitions.
+#define GMP_DEFAULT_ASYNC_SHUTDOWN_TIMEOUT 3000
+#define TEST_PREFERENCE_FAKE_RECOGNITION_SERVICE "media.webspeech.test.fake_recognition_service"
+
namespace mozilla {
template<class T> class StaticAutoPtr;
class MediaPrefs final
{
private:
@@ -55,26 +59,62 @@ private:
void Register(const char* aPreference)
{
AssertMainThread();
PrefAddVarCache(&mValue, aPreference, mValue);
}
};
// This is where DECL_MEDIA_PREF for each of the preferences should go.
- // We will keep these in an alphabetical order to make it easier to see if
- // a method accessing a pref already exists. Just add yours in the list.
- DECL_MEDIA_PREF("accessibility.monoaudio.enable", MonoAudio, bool, false);
- DECL_MEDIA_PREF("media.resampling.enabled", AudioSinkResampling, bool, false);
- DECL_MEDIA_PREF("media.resampling.rate", AudioSinkResampleRate, uint32_t, 48000);
- DECL_MEDIA_PREF("media.forcestereo.enabled", AudioSinkForceStereo, bool, true);
+
+ // AudioSink
+ DECL_MEDIA_PREF("accessibility.monoaudio.enable", MonoAudio, bool, false);
+ DECL_MEDIA_PREF("media.resampling.enabled", AudioSinkResampling, bool, false);
+ DECL_MEDIA_PREF("media.resampling.rate", AudioSinkResampleRate, uint32_t, 48000);
+ DECL_MEDIA_PREF("media.forcestereo.enabled", AudioSinkForceStereo, bool, true);
- // WARNING:
- // Please make sure that you've added your new preference to the list above in alphabetical order.
- // Please do not just append it to the end of the list.
+ // PlatformDecoderModule
+ DECL_MEDIA_PREF("media.apple.forcevda", AppleForceVDA, bool, false);
+ DECL_MEDIA_PREF("media.gmp.insecure.allow", GMPAllowInsecure, bool, false);
+ DECL_MEDIA_PREF("media.gmp.async-shutdown-timeout", GMPAsyncShutdownTimeout, uint32_t, GMP_DEFAULT_ASYNC_SHUTDOWN_TIMEOUT);
+ DECL_MEDIA_PREF("media.eme.enabled", EMEEnabled, bool, false);
+ DECL_MEDIA_PREF("media.use-blank-decoder", PDMUseBlankDecoder, bool, false);
+#ifdef MOZ_GONK_MEDIACODEC
+ DECL_MEDIA_PREF("media.gonk.enabled", PDMGonkDecoderEnabled, bool, true);
+#endif
+#ifdef MOZ_WIDGET_ANDROID
+ DECL_MEDIA_PREF("media.android-media-codec.enabled", PDMAndroidMediaCodecEnabled, bool, false);
+ DECL_MEDIA_PREF("media.android-media-codec.preferred", PDMAndroidMediaCodecPreferred, bool, false);
+#endif
+#ifdef MOZ_FFMPEG
+ DECL_MEDIA_PREF("media.ffmpeg.enabled", PDMFFmpegEnabled, bool, true);
+#endif
+#ifdef MOZ_FFVPX
+ DECL_MEDIA_PREF("media.ffvpx.enabled", PDMFFVPXEnabled, bool, true);
+#endif
+#ifdef XP_WIN
+ DECL_MEDIA_PREF("media.wmf.enabled", PDMWMFEnabled, bool, true);
+ DECL_MEDIA_PREF("media.webm.intel_decoder.enabled", PDMWMFIntelDecoderEnabled, bool, false);
+ DECL_MEDIA_PREF("media.wmf.low-latency.enabled", PDMWMFLowLatencyEnabled, bool, false);
+ DECL_MEDIA_PREF("media.wmf.decoder.thread-count", PDMWMFThreadCount, int32_t, -1);
+#endif
+ DECL_MEDIA_PREF("media.decoder.fuzzing.enabled", PDMFuzzingEnabled, bool, false);
+ DECL_MEDIA_PREF("media.decoder.fuzzing.video-output-minimum-interval-ms", PDMFuzzingInterval, uint32_t, 0);
+ DECL_MEDIA_PREF("media.decoder.fuzzing.dont-delay-inputexhausted", PDMFuzzingDelayInputExhausted, bool, true);
+ DECL_MEDIA_PREF("media.gmp.decoder.enabled", PDMGMPEnabled, bool, true);
+ DECL_MEDIA_PREF("media.gmp.decoder.aac", GMPAACPreferred, uint32_t, 0);
+ DECL_MEDIA_PREF("media.gmp.decoder.h264", GMPH264Preferred, uint32_t, 0);
+
+ // WebSpeech
+ DECL_MEDIA_PREF("media.webspeech.synth.force_global_queue", WebSpeechForceGlobal, bool, false);
+ DECL_MEDIA_PREF("media.webspeech.test.enable", WebSpeechTestEnabled, bool, false);
+ DECL_MEDIA_PREF("media.webspeech.test.fake_fsm_events", WebSpeechFakeFSMEvents, bool, false);
+ DECL_MEDIA_PREF(TEST_PREFERENCE_FAKE_RECOGNITION_SERVICE, WebSpeechFakeRecognitionService, bool, false);
+ DECL_MEDIA_PREF("media.webspeech.recognition.enable", WebSpeechRecognitionEnabled, bool, false);
+ DECL_MEDIA_PREF("media.webspeech.recognition.force_enable", WebSpeechRecognitionForceEnabled, bool, false);
public:
// Manage the singleton:
static MediaPrefs& GetSingleton();
static bool SingletonExists();
private:
template<class T> friend class StaticAutoPtr;
--- a/dom/media/eme/MediaKeySystemAccess.cpp
+++ b/dom/media/eme/MediaKeySystemAccess.cpp
@@ -3,16 +3,17 @@
/* 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 "mozilla/dom/ContentChild.h"
#include "mozilla/dom/MediaKeySystemAccess.h"
#include "mozilla/dom/MediaKeySystemAccessBinding.h"
#include "mozilla/Preferences.h"
+#include "MediaPrefs.h"
#include "nsContentTypeParser.h"
#ifdef MOZ_FMP4
#include "MP4Decoder.h"
#endif
#ifdef XP_WIN
#include "mozilla/WindowsVersion.h"
#include "WMFDecoderModule.h"
#endif
@@ -256,17 +257,17 @@ EnsureMinCDMVersion(mozIGeckoMediaPlugin
/* static */
MediaKeySystemStatus
MediaKeySystemAccess::GetKeySystemStatus(const nsAString& aKeySystem,
int32_t aMinCdmVersion,
nsACString& aOutMessage,
nsACString& aOutCdmVersion)
{
- MOZ_ASSERT(Preferences::GetBool("media.eme.enabled", false));
+ MOZ_ASSERT(MediaPrefs::EMEEnabled());
nsCOMPtr<mozIGeckoMediaPluginService> mps =
do_GetService("@mozilla.org/gecko-media-plugin-service;1");
if (NS_WARN_IF(!mps)) {
aOutMessage = NS_LITERAL_CSTRING("Failed to get GMP service");
return MediaKeySystemStatus::Error;
}
if (aKeySystem.EqualsLiteral("org.w3.clearkey")) {
--- a/dom/media/eme/MediaKeySystemAccessManager.cpp
+++ b/dom/media/eme/MediaKeySystemAccessManager.cpp
@@ -1,15 +1,15 @@
/* 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 "MediaKeySystemAccessManager.h"
#include "DecoderDoctorDiagnostics.h"
-#include "mozilla/Preferences.h"
+#include "MediaPrefs.h"
#include "mozilla/EMEUtils.h"
#include "nsServiceManagerUtils.h"
#include "nsComponentManagerUtils.h"
#include "nsIObserverService.h"
#include "mozilla/Services.h"
#include "mozilla/DetailedPromise.h"
#ifdef XP_WIN
#include "mozilla/WindowsVersion.h"
@@ -92,17 +92,17 @@ MediaKeySystemAccessManager::Request(Det
aPromise->MaybeReject(NS_ERROR_DOM_NOT_SUPPORTED_ERR,
NS_LITERAL_CSTRING("Key system string is invalid,"
" or key system is unsupported"));
diagnostics.StoreMediaKeySystemAccess(mWindow->GetExtantDoc(),
aKeySystem, false, __func__);
return;
}
- if (!Preferences::GetBool("media.eme.enabled", false)) {
+ if (!MediaPrefs::EMEEnabled()) {
// EME disabled by user, send notification to chrome so UI can inform user.
MediaKeySystemAccess::NotifyObservers(mWindow,
aKeySystem,
MediaKeySystemStatus::Api_disabled);
aPromise->MaybeReject(NS_ERROR_DOM_NOT_SUPPORTED_ERR,
NS_LITERAL_CSTRING("EME has been preffed off"));
diagnostics.StoreMediaKeySystemAccess(mWindow->GetExtantDoc(),
aKeySystem, false, __func__);
--- a/dom/media/eme/MediaKeys.cpp
+++ b/dom/media/eme/MediaKeys.cpp
@@ -12,17 +12,16 @@
#include "mozilla/dom/MediaKeyError.h"
#include "mozilla/dom/MediaKeySession.h"
#include "mozilla/dom/DOMException.h"
#include "mozilla/dom/UnionTypes.h"
#include "mozilla/CDMProxy.h"
#include "mozilla/EMEUtils.h"
#include "nsContentUtils.h"
#include "nsIScriptObjectPrincipal.h"
-#include "mozilla/Preferences.h"
#include "nsContentTypeParser.h"
#ifdef MOZ_FMP4
#include "MP4Decoder.h"
#endif
#ifdef XP_WIN
#include "mozilla/WindowsVersion.h"
#endif
#include "nsContentCID.h"
--- a/dom/media/gmp/GMPParent.cpp
+++ b/dom/media/gmp/GMPParent.cpp
@@ -17,16 +17,17 @@
#include "mozilla/unused.h"
#include "nsIObserverService.h"
#include "GMPTimerParent.h"
#include "runnable_utils.h"
#if defined(XP_LINUX) && defined(MOZ_GMP_SANDBOX)
#include "mozilla/SandboxInfo.h"
#endif
#include "GMPContentParent.h"
+#include "MediaPrefs.h"
#include "mozilla/dom/CrashReporterParent.h"
using mozilla::dom::CrashReporterParent;
using mozilla::ipc::GeckoChildProcessHost;
#ifdef MOZ_CRASHREPORTER
#include "nsPrintfCString.h"
using CrashReporter::AnnotationTable;
@@ -247,17 +248,17 @@ GMPParent::EnsureAsyncShutdownTimeoutSet
// Set timer to abort waiting for plugin to shutdown if it takes
// too long.
rv = mAsyncShutdownTimeout->SetTarget(mGMPThread);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
- int32_t timeout = GMP_DEFAULT_ASYNC_SHUTDONW_TIMEOUT;
+ int32_t timeout = MediaPrefs::GMPAsyncShutdownTimeout();
RefPtr<GeckoMediaPluginServiceParent> service =
GeckoMediaPluginServiceParent::GetSingleton();
if (service) {
timeout = service->AsyncShutdownTimeoutMs();
}
rv = mAsyncShutdownTimeout->InitWithFuncCallback(
&AbortWaitingForGMPAsyncShutdown, this, timeout,
nsITimer::TYPE_ONE_SHOT);
--- a/dom/media/gmp/GMPService.cpp
+++ b/dom/media/gmp/GMPService.cpp
@@ -8,28 +8,26 @@
#include "GMPServiceChild.h"
#include "GMPContentParent.h"
#include "prio.h"
#include "mozilla/Logging.h"
#include "GMPParent.h"
#include "GMPVideoDecoderParent.h"
#include "nsIObserverService.h"
#include "GeckoChildProcessHost.h"
-#include "mozilla/Preferences.h"
#include "mozilla/ClearOnShutdown.h"
#include "mozilla/SyncRunnable.h"
#include "nsXPCOMPrivate.h"
#include "mozilla/Services.h"
#include "nsNativeCharsetUtils.h"
#include "nsIConsoleService.h"
#include "mozilla/unused.h"
#include "GMPDecryptorParent.h"
#include "GMPAudioDecoderParent.h"
#include "nsComponentManagerUtils.h"
-#include "mozilla/Preferences.h"
#include "runnable_utils.h"
#include "VideoUtils.h"
#if defined(XP_LINUX) && defined(MOZ_GMP_SANDBOX)
#include "mozilla/SandboxInfo.h"
#endif
#include "nsAppDirectoryServiceDefs.h"
#include "nsDirectoryServiceUtils.h"
#include "nsDirectoryServiceDefs.h"
--- a/dom/media/gmp/GMPService.h
+++ b/dom/media/gmp/GMPService.h
@@ -26,18 +26,16 @@ template <class> struct already_AddRefed
namespace mozilla {
extern LogModule* GetGMPLog();
namespace gmp {
class GetGMPContentParentCallback;
-#define GMP_DEFAULT_ASYNC_SHUTDONW_TIMEOUT 3000
-
class GeckoMediaPluginService : public mozIGeckoMediaPluginService
, public nsIObserver
{
public:
static already_AddRefed<GeckoMediaPluginService> GetGeckoMediaPluginService();
virtual nsresult Init();
--- a/dom/media/gmp/GMPServiceChild.h
+++ b/dom/media/gmp/GMPServiceChild.h
@@ -10,18 +10,16 @@
#include "base/process.h"
#include "mozilla/ipc/Transport.h"
#include "mozilla/gmp/PGMPServiceChild.h"
#include "nsRefPtrHashtable.h"
namespace mozilla {
namespace gmp {
-#define GMP_DEFAULT_ASYNC_SHUTDONW_TIMEOUT 3000
-
class GMPContentParent;
class GMPServiceChild;
class GetServiceChildCallback
{
public:
GetServiceChildCallback()
{
--- a/dom/media/gmp/GMPServiceParent.cpp
+++ b/dom/media/gmp/GMPServiceParent.cpp
@@ -17,17 +17,16 @@
#include "nsXPCOMPrivate.h"
#include "mozilla/Services.h"
#include "nsNativeCharsetUtils.h"
#include "nsIConsoleService.h"
#include "mozilla/unused.h"
#include "GMPDecryptorParent.h"
#include "GMPAudioDecoderParent.h"
#include "nsComponentManagerUtils.h"
-#include "mozilla/Preferences.h"
#include "runnable_utils.h"
#include "VideoUtils.h"
#if defined(XP_LINUX) && defined(MOZ_GMP_SANDBOX)
#include "mozilla/SandboxInfo.h"
#endif
#include "nsAppDirectoryServiceDefs.h"
#include "nsDirectoryServiceUtils.h"
#include "nsDirectoryServiceDefs.h"
@@ -36,16 +35,17 @@
#include "nsISimpleEnumerator.h"
#if defined(MOZ_CRASHREPORTER)
#include "nsExceptionHandler.h"
#include "nsPrintfCString.h"
#endif
#include "nsIXULRuntime.h"
#include "GMPDecoderModule.h"
#include <limits>
+#include "MediaPrefs.h"
namespace mozilla {
#ifdef LOG
#undef LOG
#endif
#define LOGD(msg) MOZ_LOG(GetGMPLog(), mozilla::LogLevel::Debug, msg)
@@ -75,53 +75,40 @@ GeckoMediaPluginServiceParent::GetSingle
#endif
return service.forget().downcast<GeckoMediaPluginServiceParent>();
}
NS_IMPL_ISUPPORTS_INHERITED(GeckoMediaPluginServiceParent,
GeckoMediaPluginService,
mozIGeckoMediaPluginChromeService)
-static int32_t sMaxAsyncShutdownWaitMs = 0;
-static bool sAllowInsecureGMP = false;
-static bool sHaveSetGMPServiceParentPrefCaches = false;
-
GeckoMediaPluginServiceParent::GeckoMediaPluginServiceParent()
: mShuttingDown(false)
#ifdef MOZ_CRASHREPORTER
, mAsyncShutdownPluginStatesMutex("GeckoMediaPluginService::mAsyncShutdownPluginStatesMutex")
#endif
, mScannedPluginOnDisk(false)
, mWaitingForPluginsSyncShutdown(false)
, mInitPromiseMonitor("GeckoMediaPluginServiceParent::mInitPromiseMonitor")
, mLoadPluginsFromDiskComplete(false)
{
MOZ_ASSERT(NS_IsMainThread());
- if (!sHaveSetGMPServiceParentPrefCaches) {
- sHaveSetGMPServiceParentPrefCaches = true;
- Preferences::AddIntVarCache(&sMaxAsyncShutdownWaitMs,
- "media.gmp.async-shutdown-timeout",
- GMP_DEFAULT_ASYNC_SHUTDONW_TIMEOUT);
- Preferences::AddBoolVarCache(&sAllowInsecureGMP,
- "media.gmp.insecure.allow", false);
- }
mInitPromise.SetMonitor(&mInitPromiseMonitor);
}
GeckoMediaPluginServiceParent::~GeckoMediaPluginServiceParent()
{
MOZ_ASSERT(mPlugins.IsEmpty());
MOZ_ASSERT(mAsyncShutdownPlugins.IsEmpty());
}
int32_t
GeckoMediaPluginServiceParent::AsyncShutdownTimeoutMs()
{
- MOZ_ASSERT(sHaveSetGMPServiceParentPrefCaches);
- return sMaxAsyncShutdownWaitMs;
+ return MediaPrefs::GMPAsyncShutdownTimeout();
}
nsresult
GeckoMediaPluginServiceParent::Init()
{
MOZ_ASSERT(NS_IsMainThread());
nsCOMPtr<nsIObserverService> obsService = mozilla::services::GetObserverService();
@@ -1052,17 +1039,17 @@ GeckoMediaPluginServiceParent::SelectPlu
return nullptr;
}
RefPtr<GMPParent>
CreateGMPParent()
{
#if defined(XP_LINUX) && defined(MOZ_GMP_SANDBOX)
if (!SandboxInfo::Get().CanSandboxMedia()) {
- if (!sAllowInsecureGMP) {
+ if (!MediaPrefs::GMPAllowInsecure()) {
NS_WARNING("Denying media plugin load due to lack of sandboxing.");
return nullptr;
}
NS_WARNING("Loading media plugin despite lack of sandboxing.");
}
#endif
return new GMPParent();
}
--- a/dom/media/gmp/GMPServiceParent.h
+++ b/dom/media/gmp/GMPServiceParent.h
@@ -18,18 +18,16 @@
template <class> struct already_AddRefed;
namespace mozilla {
namespace gmp {
class GMPParent;
-#define GMP_DEFAULT_ASYNC_SHUTDONW_TIMEOUT 3000
-
class GeckoMediaPluginServiceParent final : public GeckoMediaPluginService
, public mozIGeckoMediaPluginChromeService
{
public:
static already_AddRefed<GeckoMediaPluginServiceParent> GetSingleton();
GeckoMediaPluginServiceParent();
nsresult Init() override;
--- a/dom/media/gtest/TestGMPCrossOrigin.cpp
+++ b/dom/media/gtest/TestGMPCrossOrigin.cpp
@@ -8,16 +8,17 @@
#include "nsIObserverService.h"
#include "mozilla/Services.h"
#include "mozilla/StaticPtr.h"
#include "GMPTestMonitor.h"
#include "GMPVideoDecoderProxy.h"
#include "GMPVideoEncoderProxy.h"
#include "GMPDecryptorProxy.h"
#include "GMPServiceParent.h"
+#include "MediaPrefs.h"
#include "nsAppDirectoryServiceDefs.h"
#include "nsIFile.h"
#include "nsISimpleEnumerator.h"
#include "mozilla/Atomics.h"
#include "nsNSSComponent.h"
#include "mozilla/DebugOnly.h"
#if defined(XP_WIN)
@@ -28,16 +29,17 @@ using namespace std;
using namespace mozilla;
using namespace mozilla::gmp;
struct GMPTestRunner
{
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(GMPTestRunner)
+ GMPTestRunner() { MediaPrefs::GetSingleton(); }
void DoTest(void (GMPTestRunner::*aTestMethod)(GMPTestMonitor&));
void RunTestGMPTestCodec1(GMPTestMonitor& aMonitor);
void RunTestGMPTestCodec2(GMPTestMonitor& aMonitor);
void RunTestGMPTestCodec3(GMPTestMonitor& aMonitor);
void RunTestGMPCrossOrigin1(GMPTestMonitor& aMonitor);
void RunTestGMPCrossOrigin2(GMPTestMonitor& aMonitor);
void RunTestGMPCrossOrigin3(GMPTestMonitor& aMonitor);
void RunTestGMPCrossOrigin4(GMPTestMonitor& aMonitor);
--- a/dom/media/gtest/TestGMPRemoveAndDelete.cpp
+++ b/dom/media/gtest/TestGMPRemoveAndDelete.cpp
@@ -11,16 +11,17 @@
#include "mozilla/Services.h"
#include "nsDirectoryServiceDefs.h"
#include "nsIObserverService.h"
#include "GMPVideoDecoderProxy.h"
#include "GMPServiceParent.h"
#include "GMPService.h"
#include "GMPUtils.h"
#include "mozilla/StaticPtr.h"
+#include "MediaPrefs.h"
#define GMP_DIR_NAME NS_LITERAL_STRING("gmp-fakeopenh264")
#define GMP_OLD_VERSION NS_LITERAL_STRING("1.0")
#define GMP_NEW_VERSION NS_LITERAL_STRING("1.1")
#define GMP_DELETED_TOPIC "gmp-directory-deleted"
#define EXPECT_OK(X) EXPECT_TRUE(NS_SUCCEEDED(X))
@@ -222,16 +223,18 @@ GMPRemoveTest::~GMPRemoveTest()
EXPECT_TRUE(NS_SUCCEEDED(mTmpDir->Exists(&exists)) && !exists);
EXPECT_OK(GetServiceParent()->AddPluginDirectory(mOriginalPath));
}
void
GMPRemoveTest::Setup()
{
+ // Initialize media preferences.
+ MediaPrefs::GetSingleton();
GeneratePlugin();
GetService()->GetThread(getter_AddRefs(mGMPThread));
// Spin the event loop until the GMP service has had a chance to complete
// adding GMPs from MOZ_GMP_PATH. Otherwise, the RemovePluginDirectory()
// below may complete before we're finished adding GMPs from MOZ_GMP_PATH,
// and we'll end up not removing the GMP, and the test will fail.
RefPtr<AbstractThread> thread(GetServiceParent()->GetAbstractGMPThread());
--- a/dom/media/gtest/TestGMPUtils.cpp
+++ b/dom/media/gtest/TestGMPUtils.cpp
@@ -2,28 +2,31 @@
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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 "gtest/gtest.h"
#include "GMPUtils.h"
#include "nsString.h"
+#include "MediaPrefs.h"
#include <string>
#include <vector>
using namespace std;
using namespace mozilla;
void TestSplitAt(const char* aInput,
const char* aDelims,
size_t aNumExpectedTokens,
const char* aExpectedTokens[])
{
+ // Initialize media preferences.
+ MediaPrefs::GetSingleton();
nsCString input(aInput);
nsTArray<nsCString> tokens;
SplitAt(aDelims, input, tokens);
EXPECT_EQ(tokens.Length(), aNumExpectedTokens) << "Should get expected number of tokens";
for (size_t i = 0; i < tokens.Length(); i++) {
EXPECT_TRUE(tokens[i].EqualsASCII(aExpectedTokens[i]))
<< "Tokenize fail; expected=" << aExpectedTokens[i] << " got=" <<
tokens[i].BeginReading();
--- a/dom/media/mediasource/MediaSourceDecoder.cpp
+++ b/dom/media/mediasource/MediaSourceDecoder.cpp
@@ -2,17 +2,16 @@
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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 "MediaSourceDecoder.h"
#include "mozilla/Logging.h"
#include "mozilla/dom/HTMLMediaElement.h"
-#include "mozilla/Preferences.h"
#include "MediaDecoderStateMachine.h"
#include "MediaSource.h"
#include "MediaSourceResource.h"
#include "MediaSourceUtils.h"
#include "VideoUtils.h"
#include "MediaSourceDemuxer.h"
#include "SourceBufferList.h"
#include <algorithm>
--- a/dom/media/omx/OmxDecoder.cpp
+++ b/dom/media/omx/OmxDecoder.cpp
@@ -22,17 +22,16 @@
#if defined(MOZ_WIDGET_GONK) && ANDROID_VERSION >= 17
#include <gui/Surface.h>
#else
#include <gui/SurfaceTextureClient.h>
#endif
#include "mozilla/layers/GrallocTextureClient.h"
#include "mozilla/layers/TextureClient.h"
-#include "mozilla/Preferences.h"
#include "mozilla/Types.h"
#include "mozilla/Monitor.h"
#include "nsMimeTypes.h"
#include "MPAPI.h"
#include "mozilla/Logging.h"
#include "GonkNativeWindow.h"
#include "OMXCodecProxy.h"
--- a/dom/media/platforms/PDMFactory.cpp
+++ b/dom/media/platforms/PDMFactory.cpp
@@ -21,22 +21,22 @@
#ifdef MOZ_GONK_MEDIACODEC
#include "GonkDecoderModule.h"
#endif
#ifdef MOZ_WIDGET_ANDROID
#include "AndroidDecoderModule.h"
#endif
#include "GMPDecoderModule.h"
-#include "mozilla/Preferences.h"
#include "mozilla/TaskQueue.h"
#include "mozilla/SharedThreadPool.h"
#include "MediaInfo.h"
+#include "MediaPrefs.h"
#include "FuzzingWrapper.h"
#include "H264Converter.h"
#include "AgnosticDecoderModule.h"
#ifdef MOZ_EME
#include "EMEDecoderModule.h"
#include "mozilla/CDMProxy.h"
@@ -44,84 +44,29 @@
#include "DecoderDoctorDiagnostics.h"
namespace mozilla {
extern already_AddRefed<PlatformDecoderModule> CreateAgnosticDecoderModule();
extern already_AddRefed<PlatformDecoderModule> CreateBlankDecoderModule();
-bool PDMFactory::sUseBlankDecoder = false;
-#ifdef MOZ_GONK_MEDIACODEC
-bool PDMFactory::sGonkDecoderEnabled = false;
-#endif
-#ifdef MOZ_WIDGET_ANDROID
-bool PDMFactory::sAndroidMCDecoderEnabled = false;
-bool PDMFactory::sAndroidMCDecoderPreferred = false;
-#endif
-bool PDMFactory::sGMPDecoderEnabled = false;
-#ifdef MOZ_FFVPX
-bool PDMFactory::sFFVPXDecoderEnabled = false;
-#endif
-#ifdef MOZ_FFMPEG
-bool PDMFactory::sFFmpegDecoderEnabled = false;
-#endif
-#ifdef XP_WIN
-bool PDMFactory::sWMFDecoderEnabled = false;
-#endif
-
-bool PDMFactory::sEnableFuzzingWrapper = false;
-uint32_t PDMFactory::sVideoOutputMinimumInterval_ms = 0;
-bool PDMFactory::sDontDelayInputExhausted = false;
-
/* static */
void
PDMFactory::Init()
{
MOZ_ASSERT(NS_IsMainThread());
static bool alreadyInitialized = false;
if (alreadyInitialized) {
return;
}
alreadyInitialized = true;
- Preferences::AddBoolVarCache(&sUseBlankDecoder,
- "media.use-blank-decoder", false);
-#ifdef MOZ_GONK_MEDIACODEC
- Preferences::AddBoolVarCache(&sGonkDecoderEnabled,
- "media.gonk.enabled", true);
-#endif
-#ifdef MOZ_WIDGET_ANDROID
- Preferences::AddBoolVarCache(&sAndroidMCDecoderEnabled,
- "media.android-media-codec.enabled", false);
- Preferences::AddBoolVarCache(&sAndroidMCDecoderPreferred,
- "media.android-media-codec.preferred", false);
-#endif
-
- Preferences::AddBoolVarCache(&sGMPDecoderEnabled,
- "media.gmp.decoder.enabled", true);
-#ifdef MOZ_FFMPEG
- Preferences::AddBoolVarCache(&sFFmpegDecoderEnabled,
- "media.ffmpeg.enabled", true);
-#endif
-#ifdef MOZ_FFVPX
- Preferences::AddBoolVarCache(&sFFVPXDecoderEnabled,
- "media.ffvpx.enabled", true);
-#endif
-#ifdef XP_WIN
- Preferences::AddBoolVarCache(&sWMFDecoderEnabled,
- "media.wmf.enabled", true);
-#endif
-
- Preferences::AddBoolVarCache(&sEnableFuzzingWrapper,
- "media.decoder.fuzzing.enabled", false);
- Preferences::AddUintVarCache(&sVideoOutputMinimumInterval_ms,
- "media.decoder.fuzzing.video-output-minimum-interval-ms", 0);
- Preferences::AddBoolVarCache(&sDontDelayInputExhausted,
- "media.decoder.fuzzing.dont-delay-inputexhausted", false);
+ // Ensure MediaPrefs are initialized.
+ MediaPrefs::GetSingleton();
#ifdef XP_WIN
WMFDecoderModule::Init();
#endif
#ifdef MOZ_APPLEMEDIA
AppleDecoderModule::Init();
#endif
#ifdef MOZ_FFVPX
@@ -217,21 +162,21 @@ PDMFactory::CreateDecoderWithPDM(Platfor
}
if (!aConfig.GetAsVideoInfo()) {
return nullptr;
}
MediaDataDecoderCallback* callback = aCallback;
RefPtr<DecoderCallbackFuzzingWrapper> callbackWrapper;
- if (sEnableFuzzingWrapper) {
+ if (MediaPrefs::PDMFuzzingEnabled()) {
callbackWrapper = new DecoderCallbackFuzzingWrapper(aCallback);
callbackWrapper->SetVideoOutputMinimumInterval(
- TimeDuration::FromMilliseconds(sVideoOutputMinimumInterval_ms));
- callbackWrapper->SetDontDelayInputExhausted(sDontDelayInputExhausted);
+ TimeDuration::FromMilliseconds(MediaPrefs::PDMFuzzingInterval()));
+ callbackWrapper->SetDontDelayInputExhausted(!MediaPrefs::PDMFuzzingDelayInputExhausted());
callback = callbackWrapper.get();
}
if (H264Converter::IsH264(aConfig)) {
RefPtr<H264Converter> h
= new H264Converter(aPDM,
*aConfig.GetAsVideoInfo(),
aLayersBackend,
@@ -273,74 +218,75 @@ PDMFactory::SupportsMimeType(const nsACS
return !!current;
}
void
PDMFactory::CreatePDMs()
{
RefPtr<PlatformDecoderModule> m;
- if (sUseBlankDecoder) {
+ if (MediaPrefs::PDMUseBlankDecoder()) {
m = CreateBlankDecoderModule();
StartupPDM(m);
// The Blank PDM SupportsMimeType reports true for all codecs; the creation
// of its decoder is infallible. As such it will be used for all media, we
// can stop creating more PDM from this point.
return;
}
#ifdef MOZ_WIDGET_ANDROID
- if(sAndroidMCDecoderPreferred && sAndroidMCDecoderEnabled) {
+ if(MediaPrefs::PDMAndroidMediaCodecPreferred() &&
+ MediaPrefs::PDMAndroidMediaCodecEnabled()) {
m = new AndroidDecoderModule();
StartupPDM(m);
}
#endif
#ifdef XP_WIN
- if (sWMFDecoderEnabled) {
+ if (MediaPrefs::PDMWMFEnabled()) {
m = new WMFDecoderModule();
if (!StartupPDM(m)) {
mWMFFailedToLoad = true;
}
}
#endif
#ifdef MOZ_FFVPX
- if (sFFVPXDecoderEnabled) {
+ if (MediaPrefs::PDMFFVPXEnabled()) {
m = FFVPXRuntimeLinker::CreateDecoderModule();
StartupPDM(m);
}
#endif
#ifdef MOZ_FFMPEG
- if (sFFmpegDecoderEnabled) {
+ if (MediaPrefs::PDMFFmpegEnabled()) {
m = FFmpegRuntimeLinker::CreateDecoderModule();
if (!StartupPDM(m)) {
mFFmpegFailedToLoad = true;
}
}
#endif
#ifdef MOZ_APPLEMEDIA
m = new AppleDecoderModule();
StartupPDM(m);
#endif
#ifdef MOZ_GONK_MEDIACODEC
- if (sGonkDecoderEnabled) {
+ if (MediaPrefs::PDMGonkDecoderEnabled()) {
m = new GonkDecoderModule();
StartupPDM(m);
}
#endif
#ifdef MOZ_WIDGET_ANDROID
- if(sAndroidMCDecoderEnabled){
+ if(MediaPrefs::PDMAndroidMediaCodecEnabled()){
m = new AndroidDecoderModule();
StartupPDM(m);
}
#endif
m = new AgnosticDecoderModule();
StartupPDM(m);
- if (sGMPDecoderEnabled) {
+ if (MediaPrefs::PDMGMPEnabled()) {
m = new GMPDecoderModule();
if (!StartupPDM(m)) {
mGMPPDMFailedToStartup = true;
}
}
}
bool
--- a/dom/media/platforms/PDMFactory.h
+++ b/dom/media/platforms/PDMFactory.h
@@ -64,39 +64,16 @@ private:
CreateDecoderWithPDM(PlatformDecoderModule* aPDM,
const TrackInfo& aConfig,
FlushableTaskQueue* aTaskQueue,
MediaDataDecoderCallback* aCallback,
DecoderDoctorDiagnostics* aDiagnostics,
layers::LayersBackend aLayersBackend,
layers::ImageContainer* aImageContainer);
- // PDM pref caches...
- static bool sUseBlankDecoder;
-#ifdef MOZ_GONK_MEDIACODEC
- static bool sGonkDecoderEnabled;
-#endif
-#ifdef MOZ_WIDGET_ANDROID
- static bool sAndroidMCDecoderPreferred;
- static bool sAndroidMCDecoderEnabled;
-#endif
- static bool sGMPDecoderEnabled;
-#ifdef MOZ_FFVPX
- static bool sFFVPXDecoderEnabled;
-#endif
-#ifdef MOZ_FFMPEG
- static bool sFFmpegDecoderEnabled;
-#endif
-#ifdef XP_WIN
- static bool sWMFDecoderEnabled;
-#endif
- static bool sEnableFuzzingWrapper;
- static uint32_t sVideoOutputMinimumInterval_ms;
- static bool sDontDelayInputExhausted;
-
nsTArray<RefPtr<PlatformDecoderModule>> mCurrentPDMs;
RefPtr<PlatformDecoderModule> mEMEPDM;
bool mWMFFailedToLoad = false;
bool mFFmpegFailedToLoad = false;
bool mGMPPDMFailedToStartup = false;
};
--- a/dom/media/platforms/agnostic/gmp/GMPDecoderModule.cpp
+++ b/dom/media/platforms/agnostic/gmp/GMPDecoderModule.cpp
@@ -4,19 +4,19 @@
* 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 "GMPDecoderModule.h"
#include "DecoderDoctorDiagnostics.h"
#include "GMPAudioDecoder.h"
#include "GMPVideoDecoder.h"
#include "MediaDataDecoderProxy.h"
+#include "MediaPrefs.h"
#include "mozIGeckoMediaPluginService.h"
#include "nsServiceManagerUtils.h"
-#include "mozilla/Preferences.h"
#include "mozilla/StaticMutex.h"
#include "gmp-audio-decode.h"
#include "gmp-video-decode.h"
#ifdef XP_WIN
#include "WMFDecoderModule.h"
#endif
namespace mozilla {
@@ -170,52 +170,44 @@ GMPDecoderModule::UpdateUsableCodecs()
NS_LITERAL_CSTRING("aac"),
nsDependentCString(gmp.mKeySystem));
gmp.mHasH264 = HasGMPFor(NS_LITERAL_CSTRING(GMP_API_VIDEO_DECODER),
NS_LITERAL_CSTRING("h264"),
nsDependentCString(gmp.mKeySystem));
}
}
-static uint32_t sPreferredAacGmp = 0;
-static uint32_t sPreferredH264Gmp = 0;
-
/* static */
void
GMPDecoderModule::Init()
{
MOZ_ASSERT(NS_IsMainThread());
// GMPService::HasPluginForAPI is main thread only, so to implement
// SupportsMimeType() we build a table of the codecs which each whitelisted
// GMP has and update it when any GMPs are removed or added at runtime.
UpdateUsableCodecs();
-
- Preferences::AddUintVarCache(&sPreferredAacGmp,
- "media.gmp.decoder.aac", 0);
- Preferences::AddUintVarCache(&sPreferredH264Gmp,
- "media.gmp.decoder.h264", 0);
}
/* static */
const Maybe<nsCString>
GMPDecoderModule::PreferredGMP(const nsACString& aMimeType)
{
Maybe<nsCString> rv;
if (aMimeType.EqualsLiteral("audio/mp4a-latm")) {
- switch (sPreferredAacGmp) {
+ switch (MediaPrefs::GMPAACPreferred()) {
case 1: rv.emplace(NS_LITERAL_CSTRING("org.w3.clearkey")); break;
case 2: rv.emplace(NS_LITERAL_CSTRING("com.adobe.primetime")); break;
default: break;
}
}
if (aMimeType.EqualsLiteral("video/avc") ||
aMimeType.EqualsLiteral("video/mp4")) {
- switch (sPreferredH264Gmp) {
+ switch (MediaPrefs::GMPH264Preferred()) {
case 1: rv.emplace(NS_LITERAL_CSTRING("org.w3.clearkey")); break;
case 2: rv.emplace(NS_LITERAL_CSTRING("com.adobe.primetime")); break;
default: break;
}
}
return rv;
}
--- a/dom/media/platforms/apple/AppleDecoderModule.cpp
+++ b/dom/media/platforms/apple/AppleDecoderModule.cpp
@@ -7,28 +7,27 @@
#include "AppleATDecoder.h"
#include "AppleCMLinker.h"
#include "AppleDecoderModule.h"
#include "AppleVDADecoder.h"
#include "AppleVDALinker.h"
#include "AppleVTDecoder.h"
#include "AppleVTLinker.h"
#include "MacIOSurfaceImage.h"
-#include "mozilla/Preferences.h"
+#include "MediaPrefs.h"
#include "mozilla/DebugOnly.h"
#include "mozilla/Logging.h"
namespace mozilla {
bool AppleDecoderModule::sInitialized = false;
bool AppleDecoderModule::sIsCoreMediaAvailable = false;
bool AppleDecoderModule::sIsVTAvailable = false;
bool AppleDecoderModule::sIsVTHWAvailable = false;
bool AppleDecoderModule::sIsVDAAvailable = false;
-bool AppleDecoderModule::sForceVDA = false;
bool AppleDecoderModule::sCanUseHardwareVideoDecoder = true;
AppleDecoderModule::AppleDecoderModule()
{
}
AppleDecoderModule::~AppleDecoderModule()
{
@@ -39,18 +38,16 @@ void
AppleDecoderModule::Init()
{
MOZ_ASSERT(NS_IsMainThread(), "Must be on main thread.");
if (sInitialized) {
return;
}
- Preferences::AddBoolVarCache(&sForceVDA, "media.apple.forcevda", false);
-
// Ensure IOSurface framework is loaded.
MacIOSurfaceLib::LoadLibrary();
const bool loaded = MacIOSurfaceLib::isInit();
// dlopen VideoDecodeAcceleration.framework if it's available.
sIsVDAAvailable = loaded && AppleVDALinker::Link();
// dlopen CoreMedia.framework if it's available.
@@ -83,17 +80,17 @@ AppleDecoderModule::CreateVideoDecoder(c
layers::LayersBackend aLayersBackend,
layers::ImageContainer* aImageContainer,
FlushableTaskQueue* aVideoTaskQueue,
MediaDataDecoderCallback* aCallback,
DecoderDoctorDiagnostics* aDiagnostics)
{
RefPtr<MediaDataDecoder> decoder;
- if (sIsVDAAvailable && (!sIsVTHWAvailable || sForceVDA)) {
+ if (sIsVDAAvailable && (!sIsVTHWAvailable || MediaPrefs::AppleForceVDA())) {
decoder =
AppleVDADecoder::CreateVDADecoder(aConfig,
aVideoTaskQueue,
aCallback,
aImageContainer);
if (decoder) {
return decoder.forget();
}
--- a/dom/media/platforms/apple/AppleDecoderModule.h
+++ b/dom/media/platforms/apple/AppleDecoderModule.h
@@ -45,14 +45,13 @@ public:
static bool sCanUseHardwareVideoDecoder;
private:
static bool sInitialized;
static bool sIsCoreMediaAvailable;
static bool sIsVTAvailable;
static bool sIsVTHWAvailable;
static bool sIsVDAAvailable;
- static bool sForceVDA;
};
} // namespace mozilla
#endif // mozilla_AppleDecoderModule_h
--- a/dom/media/platforms/gonk/GonkDecoderModule.cpp
+++ b/dom/media/platforms/gonk/GonkDecoderModule.cpp
@@ -1,17 +1,16 @@
/* -*- 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 "GonkDecoderModule.h"
#include "GonkVideoDecoderManager.h"
#include "GonkAudioDecoderManager.h"
-#include "mozilla/Preferences.h"
#include "mozilla/DebugOnly.h"
#include "GonkMediaDataDecoder.h"
namespace mozilla {
GonkDecoderModule::GonkDecoderModule()
{
}
--- a/dom/media/platforms/wmf/WMFDecoderModule.cpp
+++ b/dom/media/platforms/wmf/WMFDecoderModule.cpp
@@ -4,95 +4,73 @@
* 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 "WMF.h"
#include "WMFDecoderModule.h"
#include "WMFVideoMFTManager.h"
#include "WMFAudioMFTManager.h"
#include "MFTDecoder.h"
-#include "mozilla/Preferences.h"
#include "mozilla/DebugOnly.h"
#include "mozilla/Services.h"
#include "WMFMediaDataDecoder.h"
#include "nsIWindowsRegKey.h"
#include "nsComponentManagerUtils.h"
#include "nsServiceManagerUtils.h"
#include "nsIGfxInfo.h"
#include "nsWindowsHelpers.h"
#include "GfxDriverInfo.h"
#include "gfxWindowsPlatform.h"
#include "MediaInfo.h"
+#include "MediaPrefs.h"
#include "prsystem.h"
#include "mozilla/Maybe.h"
#include "mozilla/StaticMutex.h"
namespace mozilla {
static bool sDXVAEnabled = false;
-static int sNumDecoderThreads = -1;
-static bool sIsIntelDecoderEnabled = false;
-static bool sLowLatencyMFTEnabled = false;
WMFDecoderModule::WMFDecoderModule()
: mWMFInitialized(false)
{
}
WMFDecoderModule::~WMFDecoderModule()
{
if (mWMFInitialized) {
DebugOnly<HRESULT> hr = wmf::MFShutdown();
NS_ASSERTION(SUCCEEDED(hr), "MFShutdown failed");
}
}
-static void
-SetNumOfDecoderThreads()
-{
- MOZ_ASSERT(NS_IsMainThread(), "Preferences can only be read on main thread");
- int32_t numCores = PR_GetNumberOfProcessors();
-
- // If we have more than 4 cores, let the decoder decide how many threads.
- // On an 8 core machine, WMF chooses 4 decoder threads
- const int WMF_DECODER_DEFAULT = -1;
- int32_t prefThreadCount = Preferences::GetInt("media.wmf.decoder.thread-count", -1);
- if (prefThreadCount != WMF_DECODER_DEFAULT) {
- sNumDecoderThreads = std::max(prefThreadCount, 1);
- } else if (numCores > 4) {
- sNumDecoderThreads = WMF_DECODER_DEFAULT;
- } else {
- sNumDecoderThreads = std::max(numCores - 1, 1);
- }
-}
-
/* static */
void
WMFDecoderModule::Init()
{
MOZ_ASSERT(NS_IsMainThread(), "Must be on main thread.");
sDXVAEnabled = gfxPlatform::GetPlatform()->CanUseHardwareVideoDecoding();
- Preferences::AddBoolVarCache(&sIsIntelDecoderEnabled,
- "media.webm.intel_decoder.enabled");
- sLowLatencyMFTEnabled = Preferences::GetBool("media.wmf.low-latency.enabled", false);
- SetNumOfDecoderThreads();
}
/* static */
int
WMFDecoderModule::GetNumDecoderThreads()
{
- return sNumDecoderThreads;
-}
+ int32_t numCores = PR_GetNumberOfProcessors();
-/* static */
-bool
-WMFDecoderModule::LowLatencyMFTEnabled()
-{
- return sLowLatencyMFTEnabled;
+ // If we have more than 4 cores, let the decoder decide how many threads.
+ // On an 8 core machine, WMF chooses 4 decoder threads
+ const int WMF_DECODER_DEFAULT = -1;
+ int32_t prefThreadCount = MediaPrefs::PDMWMFThreadCount();
+ if (prefThreadCount != WMF_DECODER_DEFAULT) {
+ return std::max(prefThreadCount, 1);
+ } else if (numCores > 4) {
+ return WMF_DECODER_DEFAULT;
+ }
+ return std::max(numCores - 1, 1);
}
nsresult
WMFDecoderModule::Startup()
{
mWMFInitialized = SUCCEEDED(wmf::MFStartup());
return mWMFInitialized ? NS_OK : NS_ERROR_FAILURE;
}
@@ -227,17 +205,17 @@ WMFDecoderModule::SupportsMimeType(const
aMimeType.EqualsLiteral("video/mp4")) &&
WMFDecoderModule::HasH264()) {
return true;
}
if (aMimeType.EqualsLiteral("audio/mpeg") &&
CanCreateWMFDecoder<CLSID_CMP3DecMediaObject>()) {
return true;
}
- if (sIsIntelDecoderEnabled && sDXVAEnabled) {
+ if (MediaPrefs::PDMWMFIntelDecoderEnabled() && sDXVAEnabled) {
if (aMimeType.EqualsLiteral("video/webm; codecs=vp8") &&
CanCreateWMFDecoder<CLSID_WebmMfVp8Dec>()) {
return true;
}
if (aMimeType.EqualsLiteral("video/webm; codecs=vp9") &&
CanCreateWMFDecoder<CLSID_WebmMfVp9Dec>()) {
return true;
}
--- a/dom/media/platforms/wmf/WMFDecoderModule.h
+++ b/dom/media/platforms/wmf/WMFDecoderModule.h
@@ -39,17 +39,16 @@ public:
ConversionRequired
DecoderNeedsConversion(const TrackInfo& aConfig) const override;
// Called on main thread.
static void Init();
// Called from any thread, must call init first
static int GetNumDecoderThreads();
- static bool LowLatencyMFTEnabled();
// Accessors that report whether we have the required MFTs available
// on the system to play various codecs. Windows Vista doesn't have the
// H.264/AAC decoders if the "Platform Update Supplement for Windows Vista"
// is not installed, and Window N and KN variants also require a "Media
// Feature Pack" to be installed. Windows XP doesn't have WMF.
static bool HasAAC();
static bool HasH264();
--- a/dom/media/platforms/wmf/WMFVideoMFTManager.cpp
+++ b/dom/media/platforms/wmf/WMFVideoMFTManager.cpp
@@ -2,16 +2,17 @@
/* 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 <algorithm>
#include "WMFVideoMFTManager.h"
#include "MediaDecoderReader.h"
+#include "MediaPrefs.h"
#include "WMFUtils.h"
#include "ImageContainer.h"
#include "VideoUtils.h"
#include "DXVA2Manager.h"
#include "nsThreadUtils.h"
#include "Layers.h"
#include "mozilla/layers/LayersTypes.h"
#include "MediaInfo.h"
@@ -244,17 +245,17 @@ WMFVideoMFTManager::InitInternal(bool aF
NS_ENSURE_TRUE(SUCCEEDED(hr), false);
RefPtr<IMFAttributes> attr(decoder->GetAttributes());
UINT32 aware = 0;
if (attr) {
attr->GetUINT32(MF_SA_D3D_AWARE, &aware);
attr->SetUINT32(CODECAPI_AVDecNumWorkerThreads,
WMFDecoderModule::GetNumDecoderThreads());
- if (WMFDecoderModule::LowLatencyMFTEnabled()) {
+ if (MediaPrefs::PDMWMFLowLatencyEnabled()) {
hr = attr->SetUINT32(CODECAPI_AVLowLatencyMode, TRUE);
if (SUCCEEDED(hr)) {
LOG("Enabling Low Latency Mode");
} else {
LOG("Couldn't enable Low Latency Mode");
}
}
}
--- a/dom/media/webaudio/AudioDestinationNode.cpp
+++ b/dom/media/webaudio/AudioDestinationNode.cpp
@@ -4,17 +4,16 @@
* 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 "AudioDestinationNode.h"
#include "AlignmentUtils.h"
#include "AudioContext.h"
#include "mozilla/dom/AudioDestinationNodeBinding.h"
#include "mozilla/dom/ScriptSettings.h"
-#include "mozilla/Preferences.h"
#include "mozilla/Services.h"
#include "AudioChannelAgent.h"
#include "AudioChannelService.h"
#include "AudioNodeEngine.h"
#include "AudioNodeStream.h"
#include "MediaStreamGraph.h"
#include "OfflineAudioCompletionEvent.h"
#include "nsContentUtils.h"
--- a/dom/media/webaudio/BiquadFilterNode.cpp
+++ b/dom/media/webaudio/BiquadFilterNode.cpp
@@ -7,17 +7,16 @@
#include "BiquadFilterNode.h"
#include "AlignmentUtils.h"
#include "AudioNodeEngine.h"
#include "AudioNodeStream.h"
#include "AudioDestinationNode.h"
#include "PlayingRefChangeHandler.h"
#include "WebAudioUtils.h"
#include "blink/Biquad.h"
-#include "mozilla/Preferences.h"
#include "mozilla/UniquePtr.h"
#include "AudioParamTimeline.h"
namespace mozilla {
namespace dom {
NS_IMPL_CYCLE_COLLECTION_INHERITED(BiquadFilterNode, AudioNode,
mFrequency, mDetune, mQ, mGain)
--- a/dom/media/webaudio/OscillatorNode.h
+++ b/dom/media/webaudio/OscillatorNode.h
@@ -6,17 +6,16 @@
#ifndef OscillatorNode_h_
#define OscillatorNode_h_
#include "AudioNode.h"
#include "AudioParam.h"
#include "PeriodicWave.h"
#include "mozilla/dom/OscillatorNodeBinding.h"
-#include "mozilla/Preferences.h"
namespace mozilla {
namespace dom {
class AudioContext;
class OscillatorNode final : public AudioNode,
public MainThreadMediaStreamListener
--- a/dom/media/webaudio/PannerNode.h
+++ b/dom/media/webaudio/PannerNode.h
@@ -6,17 +6,16 @@
#ifndef PannerNode_h_
#define PannerNode_h_
#include "AudioNode.h"
#include "mozilla/dom/PannerNodeBinding.h"
#include "ThreeDPoint.h"
#include "mozilla/WeakPtr.h"
-#include "mozilla/Preferences.h"
#include "WebAudioUtils.h"
#include <set>
namespace mozilla {
namespace dom {
class AudioContext;
class AudioBufferSourceNode;
--- a/dom/media/webm/WebMDemuxer.cpp
+++ b/dom/media/webm/WebMDemuxer.cpp
@@ -8,17 +8,16 @@
#include "MediaDecoderStateMachine.h"
#include "AbstractMediaDecoder.h"
#include "MediaResource.h"
#include "WebMDemuxer.h"
#include "WebMBufferedParser.h"
#include "gfx2DGlue.h"
#include "mozilla/Atomics.h"
#include "mozilla/Endian.h"
-#include "mozilla/Preferences.h"
#include "mozilla/SharedThreadPool.h"
#include "MediaDataDemuxer.h"
#include "nsAutoRef.h"
#include "NesteggPacketHolder.h"
#include "XiphExtradata.h"
#include "prprf.h" // leaving it for PR_vsnprintf()
#include "mozilla/Snprintf.h"
--- a/dom/media/webspeech/recognition/SpeechGrammar.cpp
+++ b/dom/media/webspeech/recognition/SpeechGrammar.cpp
@@ -1,17 +1,16 @@
/* -*- 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 "SpeechGrammar.h"
-#include "mozilla/Preferences.h"
#include "mozilla/dom/SpeechGrammarBinding.h"
namespace mozilla {
namespace dom {
NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(SpeechGrammar, mParent)
NS_IMPL_CYCLE_COLLECTING_ADDREF(SpeechGrammar)
NS_IMPL_CYCLE_COLLECTING_RELEASE(SpeechGrammar)
--- a/dom/media/webspeech/recognition/SpeechRecognition.cpp
+++ b/dom/media/webspeech/recognition/SpeechRecognition.cpp
@@ -10,16 +10,18 @@
#include "nsCycleCollectionParticipant.h"
#include "mozilla/dom/BindingUtils.h"
#include "mozilla/dom/Element.h"
#include "mozilla/dom/SpeechRecognitionBinding.h"
#include "mozilla/dom/MediaStreamTrackBinding.h"
#include "mozilla/dom/MediaStreamError.h"
#include "mozilla/MediaManager.h"
+#include "mozilla/Preferences.h"
+#include "MediaPrefs.h"
#include "mozilla/Services.h"
#include "AudioSegment.h"
#include "endpointer.h"
#include "mozilla/dom/SpeechRecognitionEvent.h"
#include "nsContentUtils.h"
#include "nsIDocument.h"
@@ -65,30 +67,30 @@ GetSpeechRecognitionLog()
#define SR_LOG(...) MOZ_LOG(GetSpeechRecognitionLog(), mozilla::LogLevel::Debug, (__VA_ARGS__))
already_AddRefed<nsISpeechRecognitionService>
GetSpeechRecognitionService(const nsAString& aLang)
{
nsAutoCString speechRecognitionServiceCID;
nsAdoptingCString prefValue =
- Preferences::GetCString(PREFERENCE_DEFAULT_RECOGNITION_SERVICE);
+ Preferences::GetCString(PREFERENCE_DEFAULT_RECOGNITION_SERVICE);
nsAutoCString speechRecognitionService;
if (!aLang.IsEmpty()) {
speechRecognitionService =
NS_LITERAL_CSTRING(DEFAULT_RECOGNITION_SERVICE_PREFIX) +
NS_ConvertUTF16toUTF8(aLang);
} else if (!prefValue.IsEmpty()) {
speechRecognitionService = prefValue;
} else {
speechRecognitionService = DEFAULT_RECOGNITION_SERVICE;
}
- if (SpeechRecognition::mTestConfig.mFakeRecognitionService) {
+ if (MediaPrefs::WebSpeechFakeRecognitionService()) {
speechRecognitionServiceCID =
NS_SPEECH_RECOGNITION_SERVICE_CONTRACTID_PREFIX "fake";
} else {
speechRecognitionServiceCID =
NS_LITERAL_CSTRING(NS_SPEECH_RECOGNITION_SERVICE_CONTRACTID_PREFIX) +
speechRecognitionService;
}
@@ -102,31 +104,28 @@ NS_IMPL_CYCLE_COLLECTION_INHERITED(Speec
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(SpeechRecognition)
NS_INTERFACE_MAP_ENTRY(nsIObserver)
NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
NS_IMPL_ADDREF_INHERITED(SpeechRecognition, DOMEventTargetHelper)
NS_IMPL_RELEASE_INHERITED(SpeechRecognition, DOMEventTargetHelper)
-struct SpeechRecognition::TestConfig SpeechRecognition::mTestConfig;
-
SpeechRecognition::SpeechRecognition(nsPIDOMWindowInner* aOwnerWindow)
: DOMEventTargetHelper(aOwnerWindow)
, mEndpointer(kSAMPLE_RATE)
, mAudioSamplesPerChunk(mEndpointer.FrameSize())
, mSpeechDetectionTimer(do_CreateInstance(NS_TIMER_CONTRACTID))
, mSpeechGrammarList(new SpeechGrammarList(GetParentObject()))
, mInterimResults(false)
, mMaxAlternatives(1)
{
SR_LOG("created SpeechRecognition");
- mTestConfig.Init();
- if (mTestConfig.mEnableTests) {
+ if (MediaPrefs::WebSpeechTestEnabled()) {
nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
obs->AddObserver(this, SPEECH_RECOGNITION_TEST_EVENT_REQUEST_TOPIC, false);
obs->AddObserver(this, SPEECH_RECOGNITION_TEST_END_TOPIC, false);
}
mEndpointer.set_speech_input_complete_silence_length(
Preferences::GetInt(PREFERENCE_ENDPOINTER_SILENCE_LENGTH, 1250000));
mEndpointer.set_long_speech_input_complete_silence_length(
@@ -170,20 +169,19 @@ SpeechRecognition::IsAuthorized(JSContex
uint32_t speechRecognition = nsIPermissionManager::UNKNOWN_ACTION;
rv = mgr->TestExactPermissionFromPrincipal(principal, "speech-recognition", &speechRecognition);
if (NS_WARN_IF(NS_FAILED(rv))) {
return false;
}
bool hasPermission = (speechRecognition == nsIPermissionManager::ALLOW_ACTION);
- bool enableTests = Preferences::GetBool(TEST_PREFERENCE_ENABLE);
- bool enableRecognitionEnable = Preferences::GetBool(TEST_PREFERENCE_RECOGNITION_ENABLE);
- bool enableRecognitionForceEnable = Preferences::GetBool(TEST_PREFERENCE_RECOGNITION_FORCE_ENABLE);
- return (hasPermission || enableRecognitionForceEnable || enableTests) && enableRecognitionEnable;
+ return (hasPermission || MediaPrefs::WebSpeechRecognitionForceEnabled()
+ || MediaPrefs::WebSpeechTestEnabled())
+ && MediaPrefs::WebSpeechRecognitionEnabled();
}
already_AddRefed<SpeechRecognition>
SpeechRecognition::Constructor(const GlobalObject& aGlobal,
ErrorResult& aRv)
{
nsCOMPtr<nsPIDOMWindowInner> win = do_QueryInterface(aGlobal.GetAsSupports());
if (!win) {
@@ -612,17 +610,17 @@ SpeechRecognition::Observe(nsISupports*
DispatchError(SpeechRecognition::EVENT_AUDIO_ERROR,
SpeechRecognitionErrorCode::No_speech,
NS_LITERAL_STRING("No speech detected (timeout)"));
} else if (!strcmp(aTopic, SPEECH_RECOGNITION_TEST_END_TOPIC)) {
nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
obs->RemoveObserver(this, SPEECH_RECOGNITION_TEST_EVENT_REQUEST_TOPIC);
obs->RemoveObserver(this, SPEECH_RECOGNITION_TEST_END_TOPIC);
- } else if (mTestConfig.mFakeFSMEvents &&
+ } else if (MediaPrefs::WebSpeechFakeFSMEvents() &&
!strcmp(aTopic, SPEECH_RECOGNITION_TEST_EVENT_REQUEST_TOPIC)) {
ProcessTestEventRequest(aSubject, nsDependentString(aData));
}
return NS_OK;
}
void
@@ -630,17 +628,17 @@ SpeechRecognition::ProcessTestEventReque
{
if (aEventName.EqualsLiteral("EVENT_ABORT")) {
Abort();
} else if (aEventName.EqualsLiteral("EVENT_AUDIO_ERROR")) {
DispatchError(SpeechRecognition::EVENT_AUDIO_ERROR,
SpeechRecognitionErrorCode::Audio_capture, // TODO different codes?
NS_LITERAL_STRING("AUDIO_ERROR test event"));
} else {
- NS_ASSERTION(mTestConfig.mFakeRecognitionService,
+ NS_ASSERTION(MediaPrefs::WebSpeechFakeRecognitionService(),
"Got request for fake recognition service event, but "
TEST_PREFERENCE_FAKE_RECOGNITION_SERVICE " is unset");
// let the fake recognition service handle the request
}
return;
}
--- a/dom/media/webspeech/recognition/SpeechRecognition.h
+++ b/dom/media/webspeech/recognition/SpeechRecognition.h
@@ -16,35 +16,29 @@
#include "js/TypeDecls.h"
#include "nsIDOMNavigatorUserMedia.h"
#include "nsITimer.h"
#include "MediaEngine.h"
#include "MediaStreamGraph.h"
#include "AudioSegment.h"
#include "mozilla/WeakPtr.h"
-#include "mozilla/Preferences.h"
#include "SpeechGrammarList.h"
#include "SpeechRecognitionResultList.h"
#include "SpeechStreamListener.h"
#include "nsISpeechRecognitionService.h"
#include "endpointer.h"
#include "mozilla/dom/SpeechRecognitionError.h"
namespace mozilla {
namespace dom {
-#define TEST_PREFERENCE_ENABLE "media.webspeech.test.enable"
-#define TEST_PREFERENCE_FAKE_FSM_EVENTS "media.webspeech.test.fake_fsm_events"
-#define TEST_PREFERENCE_FAKE_RECOGNITION_SERVICE "media.webspeech.test.fake_recognition_service"
-#define TEST_PREFERENCE_RECOGNITION_ENABLE "media.webspeech.recognition.enable"
-#define TEST_PREFERENCE_RECOGNITION_FORCE_ENABLE "media.webspeech.recognition.force_enable"
#define SPEECH_RECOGNITION_TEST_EVENT_REQUEST_TOPIC "SpeechRecognitionTest:RequestEvent"
#define SPEECH_RECOGNITION_TEST_END_TOPIC "SpeechRecognitionTest:End"
class GlobalObject;
class SpeechEvent;
LogModule* GetSpeechRecognitionLog();
#define SR_LOG(...) MOZ_LOG(GetSpeechRecognitionLog(), mozilla::LogLevel::Debug, (__VA_ARGS__))
@@ -126,43 +120,16 @@ public:
};
void DispatchError(EventType aErrorType, SpeechRecognitionErrorCode aErrorCode, const nsAString& aMessage);
uint32_t FillSamplesBuffer(const int16_t* aSamples, uint32_t aSampleCount);
uint32_t SplitSamplesBuffer(const int16_t* aSamplesBuffer, uint32_t aSampleCount, nsTArray<RefPtr<SharedBuffer>>& aResult);
AudioSegment* CreateAudioSegment(nsTArray<RefPtr<SharedBuffer>>& aChunks);
void FeedAudioData(already_AddRefed<SharedBuffer> aSamples, uint32_t aDuration, MediaStreamListener* aProvider, TrackRate aTrackRate);
- static struct TestConfig
- {
- public:
- bool mEnableTests;
- bool mFakeFSMEvents;
- bool mFakeRecognitionService;
-
- void Init()
- {
- if (mInitialized) {
- return;
- }
-
- Preferences::AddBoolVarCache(&mEnableTests, TEST_PREFERENCE_ENABLE);
-
- if (mEnableTests) {
- Preferences::AddBoolVarCache(&mFakeFSMEvents, TEST_PREFERENCE_FAKE_FSM_EVENTS);
- Preferences::AddBoolVarCache(&mFakeRecognitionService, TEST_PREFERENCE_FAKE_RECOGNITION_SERVICE);
- }
-
- mInitialized = true;
- }
- private:
- bool mInitialized;
- } mTestConfig;
-
-
friend class SpeechEvent;
private:
virtual ~SpeechRecognition() {};
enum FSMState {
STATE_IDLE,
STATE_STARTING,
STATE_ESTIMATING,
--- a/dom/media/webspeech/recognition/test/FakeSpeechRecognitionService.cpp
+++ b/dom/media/webspeech/recognition/test/FakeSpeechRecognitionService.cpp
@@ -2,16 +2,17 @@
/* 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 "nsThreadUtils.h"
#include "FakeSpeechRecognitionService.h"
+#include "MediaPrefs.h"
#include "SpeechRecognition.h"
#include "SpeechRecognitionAlternative.h"
#include "SpeechRecognitionResult.h"
#include "SpeechRecognitionResultList.h"
#include "nsIObserverService.h"
#include "mozilla/Services.h"
@@ -61,17 +62,17 @@ NS_IMETHODIMP
FakeSpeechRecognitionService::Abort()
{
return NS_OK;
}
NS_IMETHODIMP
FakeSpeechRecognitionService::Observe(nsISupports* aSubject, const char* aTopic, const char16_t* aData)
{
- MOZ_ASSERT(mRecognition->mTestConfig.mFakeRecognitionService,
+ MOZ_ASSERT(MediaPrefs::WebSpeechFakeRecognitionService(),
"Got request to fake recognition service event, but "
TEST_PREFERENCE_FAKE_RECOGNITION_SERVICE " is not set");
if (!strcmp(aTopic, SPEECH_RECOGNITION_TEST_END_TOPIC)) {
nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
obs->RemoveObserver(this, SPEECH_RECOGNITION_TEST_EVENT_REQUEST_TOPIC);
obs->RemoveObserver(this, SPEECH_RECOGNITION_TEST_END_TOPIC);
--- a/dom/media/webspeech/synth/nsSynthVoiceRegistry.cpp
+++ b/dom/media/webspeech/synth/nsSynthVoiceRegistry.cpp
@@ -4,27 +4,27 @@
* 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 "nsILocaleService.h"
#include "nsISpeechService.h"
#include "nsServiceManagerUtils.h"
#include "nsCategoryManagerUtils.h"
+#include "MediaPrefs.h"
#include "SpeechSynthesisUtterance.h"
#include "SpeechSynthesisVoice.h"
#include "nsSynthVoiceRegistry.h"
#include "nsSpeechTask.h"
#include "AudioChannelService.h"
#include "nsString.h"
#include "mozilla/StaticPtr.h"
#include "mozilla/dom/ContentChild.h"
#include "mozilla/dom/ContentParent.h"
-#include "mozilla/Preferences.h"
#include "mozilla/unused.h"
#include "SpeechSynthesisChild.h"
#include "SpeechSynthesisParent.h"
#undef LOG
extern mozilla::LogModule* GetSpeechSynthLog();
#define LOG(type, msg) MOZ_LOG(GetSpeechSynthLog(), type, msg)
@@ -132,17 +132,16 @@ public:
float mPitch;
bool mIsLocal;
};
// nsSynthVoiceRegistry
static StaticRefPtr<nsSynthVoiceRegistry> gSynthVoiceRegistry;
-static bool sForceGlobalQueue = false;
NS_IMPL_ISUPPORTS(nsSynthVoiceRegistry, nsISynthVoiceRegistry)
nsSynthVoiceRegistry::nsSynthVoiceRegistry()
: mSpeechSynthChild(nullptr)
, mUseGlobalQueue(false)
, mIsSpeaking(false)
{
@@ -184,18 +183,16 @@ nsSynthVoiceRegistry::~nsSynthVoiceRegis
nsSynthVoiceRegistry*
nsSynthVoiceRegistry::GetInstance()
{
MOZ_ASSERT(NS_IsMainThread());
if (!gSynthVoiceRegistry) {
gSynthVoiceRegistry = new nsSynthVoiceRegistry();
- Preferences::AddBoolVarCache(&sForceGlobalQueue,
- "media.webspeech.synth.force_global_queue");
if (XRE_IsParentProcess()) {
// Start up all speech synth services.
NS_CreateServicesFromCategory(NS_SPEECH_SYNTH_STARTED, nullptr,
NS_SPEECH_SYNTH_STARTED);
}
}
return gSynthVoiceRegistry;
@@ -337,17 +334,17 @@ nsSynthVoiceRegistry::RemoveVoice(nsISpe
if(NS_WARN_IF(!(aService == retval->mService))) {
return NS_ERROR_INVALID_ARG;
}
mVoices.RemoveElement(retval);
mDefaultVoices.RemoveElement(retval);
mUriVoiceMap.Remove(aUri);
- if (retval->mIsQueued && !sForceGlobalQueue) {
+ if (retval->mIsQueued && !MediaPrefs::WebSpeechForceGlobal()) {
// Check if this is the last queued voice, and disable the global queue if
// it is.
bool queued = false;
for (uint32_t i = 0; i < mVoices.Length(); i++) {
VoiceData* voice = mVoices[i];
if (voice->mIsQueued) {
queued = true;
break;
@@ -708,17 +705,17 @@ nsSynthVoiceRegistry::Speak(const nsAStr
if (!voice) {
NS_WARNING("No voices found.");
aTask->DispatchError(0, 0);
return;
}
aTask->SetChosenVoiceURI(voice->mUri);
- if (mUseGlobalQueue || sForceGlobalQueue) {
+ if (mUseGlobalQueue || MediaPrefs::WebSpeechForceGlobal()) {
LOG(LogLevel::Debug,
("nsSynthVoiceRegistry::Speak queueing text='%s' lang='%s' uri='%s' rate=%f pitch=%f",
NS_ConvertUTF16toUTF8(aText).get(), NS_ConvertUTF16toUTF8(aLang).get(),
NS_ConvertUTF16toUTF8(aUri).get(), aRate, aPitch));
RefPtr<GlobalQueueItem> item = new GlobalQueueItem(voice, aTask, aText,
aVolume, aRate, aPitch);
mGlobalQueue.AppendElement(item);
@@ -786,17 +783,18 @@ nsSynthVoiceRegistry::IsSpeaking()
}
void
nsSynthVoiceRegistry::SetIsSpeaking(bool aIsSpeaking)
{
MOZ_ASSERT(XRE_IsParentProcess());
// Only set to 'true' if global queue is enabled.
- mIsSpeaking = aIsSpeaking && (mUseGlobalQueue || sForceGlobalQueue);
+ mIsSpeaking =
+ aIsSpeaking && (mUseGlobalQueue || MediaPrefs::WebSpeechForceGlobal());
nsTArray<SpeechSynthesisParent*> ssplist;
GetAllSpeechSynthActors(ssplist);
for (uint32_t i = 0; i < ssplist.Length(); ++i) {
Unused << ssplist[i]->SendIsSpeakingChanged(aIsSpeaking);
}
}