2102 lines
68 KiB
C++
2102 lines
68 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/* 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 "gfxWindowsPlatform.h"
|
|
|
|
#include "cairo.h"
|
|
#include "mozilla/ArrayUtils.h"
|
|
|
|
#include "gfxImageSurface.h"
|
|
#include "gfxWindowsSurface.h"
|
|
|
|
#include "nsUnicharUtils.h"
|
|
#include "nsUnicodeProperties.h"
|
|
|
|
#include "mozilla/Preferences.h"
|
|
#include "mozilla/Services.h"
|
|
#include "mozilla/Sprintf.h"
|
|
#include "mozilla/WindowsVersion.h"
|
|
#include "nsIGfxInfo.h"
|
|
#include "nsServiceManagerUtils.h"
|
|
#include "nsTArray.h"
|
|
#include "GeckoProfiler.h"
|
|
|
|
#include "nsIWindowsRegKey.h"
|
|
#include "nsIFile.h"
|
|
#include "plbase64.h"
|
|
#include "nsIXULRuntime.h"
|
|
#include "imgLoader.h"
|
|
|
|
#include "nsIGfxInfo.h"
|
|
|
|
#include "gfxGDIFontList.h"
|
|
#include "gfxGDIFont.h"
|
|
|
|
#include "mozilla/layers/CompositorThread.h"
|
|
#include "DeviceManagerD3D9.h"
|
|
#include "mozilla/layers/ReadbackManagerD3D11.h"
|
|
|
|
#include "WinUtils.h"
|
|
|
|
#include "gfxDWriteFontList.h"
|
|
#include "gfxDWriteFonts.h"
|
|
#include "gfxDWriteCommon.h"
|
|
#include <dwrite.h>
|
|
|
|
#include "gfxTextRun.h"
|
|
#include "gfxUserFontSet.h"
|
|
#include "nsWindowsHelpers.h"
|
|
#include "gfx2DGlue.h"
|
|
|
|
#include <string>
|
|
|
|
#include <d3d10_1.h>
|
|
|
|
#include "mozilla/gfx/2D.h"
|
|
|
|
#include "nsMemory.h"
|
|
|
|
#include <d3d11.h>
|
|
|
|
#include "nsIMemoryReporter.h"
|
|
#include <winternl.h>
|
|
#include "d3dkmtQueryStatistics.h"
|
|
|
|
#include "base/thread.h"
|
|
#include "gfxPrefs.h"
|
|
#include "gfxConfig.h"
|
|
#include "VsyncSource.h"
|
|
#include "DriverCrashGuard.h"
|
|
#include "mozilla/dom/ContentParent.h"
|
|
#include "mozilla/gfx/DeviceManagerDx.h"
|
|
#include "D3D11Checks.h"
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::gfx;
|
|
using namespace mozilla::layers;
|
|
using namespace mozilla::widget;
|
|
using namespace mozilla::image;
|
|
using namespace mozilla::unicode;
|
|
|
|
IDWriteRenderingParams* GetDwriteRenderingParams(bool aGDI)
|
|
{
|
|
gfxWindowsPlatform::TextRenderingMode mode = aGDI ?
|
|
gfxWindowsPlatform::TEXT_RENDERING_GDI_CLASSIC :
|
|
gfxWindowsPlatform::TEXT_RENDERING_NORMAL;
|
|
return gfxWindowsPlatform::GetPlatform()->GetRenderingParams(mode);
|
|
}
|
|
|
|
DCFromDrawTarget::DCFromDrawTarget(DrawTarget& aDrawTarget)
|
|
{
|
|
mDC = nullptr;
|
|
if (aDrawTarget.GetBackendType() == BackendType::CAIRO) {
|
|
cairo_t* ctx = static_cast<cairo_t*>
|
|
(aDrawTarget.GetNativeSurface(NativeSurfaceType::CAIRO_CONTEXT));
|
|
if (ctx) {
|
|
cairo_surface_t* surf = cairo_get_group_target(ctx);
|
|
if (surf) {
|
|
cairo_surface_type_t surfaceType = cairo_surface_get_type(surf);
|
|
if (surfaceType == CAIRO_SURFACE_TYPE_WIN32 ||
|
|
surfaceType == CAIRO_SURFACE_TYPE_WIN32_PRINTING) {
|
|
mDC = cairo_win32_surface_get_dc(surf);
|
|
mNeedsRelease = false;
|
|
SaveDC(mDC);
|
|
cairo_scaled_font_t* scaled = cairo_get_scaled_font(ctx);
|
|
cairo_win32_scaled_font_select_font(scaled, mDC);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!mDC) {
|
|
// Get the whole screen DC:
|
|
mDC = GetDC(nullptr);
|
|
SetGraphicsMode(mDC, GM_ADVANCED);
|
|
mNeedsRelease = true;
|
|
}
|
|
}
|
|
|
|
class GfxD2DVramReporter final : public nsIMemoryReporter
|
|
{
|
|
~GfxD2DVramReporter() {}
|
|
|
|
public:
|
|
NS_DECL_ISUPPORTS
|
|
|
|
NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
|
|
nsISupports* aData, bool aAnonymize) override
|
|
{
|
|
MOZ_COLLECT_REPORT(
|
|
"gfx-d2d-vram-draw-target", KIND_OTHER, UNITS_BYTES,
|
|
Factory::GetD2DVRAMUsageDrawTarget(),
|
|
"Video memory used by D2D DrawTargets.");
|
|
|
|
MOZ_COLLECT_REPORT(
|
|
"gfx-d2d-vram-source-surface", KIND_OTHER, UNITS_BYTES,
|
|
Factory::GetD2DVRAMUsageSourceSurface(),
|
|
"Video memory used by D2D SourceSurfaces.");
|
|
|
|
return NS_OK;
|
|
}
|
|
};
|
|
|
|
NS_IMPL_ISUPPORTS(GfxD2DVramReporter, nsIMemoryReporter)
|
|
|
|
#define GFX_USE_CLEARTYPE_ALWAYS "gfx.font_rendering.cleartype.always_use_for_content"
|
|
#define GFX_DOWNLOADABLE_FONTS_USE_CLEARTYPE "gfx.font_rendering.cleartype.use_for_downloadable_fonts"
|
|
|
|
#define GFX_CLEARTYPE_PARAMS "gfx.font_rendering.cleartype_params."
|
|
#define GFX_CLEARTYPE_PARAMS_GAMMA "gfx.font_rendering.cleartype_params.gamma"
|
|
#define GFX_CLEARTYPE_PARAMS_CONTRAST "gfx.font_rendering.cleartype_params.enhanced_contrast"
|
|
#define GFX_CLEARTYPE_PARAMS_LEVEL "gfx.font_rendering.cleartype_params.cleartype_level"
|
|
#define GFX_CLEARTYPE_PARAMS_STRUCTURE "gfx.font_rendering.cleartype_params.pixel_structure"
|
|
#define GFX_CLEARTYPE_PARAMS_MODE "gfx.font_rendering.cleartype_params.rendering_mode"
|
|
|
|
class GPUAdapterReporter final : public nsIMemoryReporter
|
|
{
|
|
// Callers must Release the DXGIAdapter after use or risk mem-leak
|
|
static bool GetDXGIAdapter(IDXGIAdapter **aDXGIAdapter)
|
|
{
|
|
ID3D11Device *d3d11Device;
|
|
IDXGIDevice *dxgiDevice;
|
|
bool result = false;
|
|
|
|
if ((d3d11Device = mozilla::gfx::Factory::GetDirect3D11Device())) {
|
|
if (d3d11Device->QueryInterface(__uuidof(IDXGIDevice), (void **)&dxgiDevice) == S_OK) {
|
|
result = (dxgiDevice->GetAdapter(aDXGIAdapter) == S_OK);
|
|
dxgiDevice->Release();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
~GPUAdapterReporter() {}
|
|
|
|
public:
|
|
NS_DECL_ISUPPORTS
|
|
|
|
NS_IMETHOD
|
|
CollectReports(nsIHandleReportCallback* aHandleReport, nsISupports* aData,
|
|
bool aAnonymize) override
|
|
{
|
|
HANDLE ProcessHandle = GetCurrentProcess();
|
|
|
|
int64_t dedicatedBytesUsed = 0;
|
|
int64_t sharedBytesUsed = 0;
|
|
int64_t committedBytesUsed = 0;
|
|
IDXGIAdapter *DXGIAdapter;
|
|
|
|
HMODULE gdi32Handle;
|
|
PFND3DKMTQS queryD3DKMTStatistics = nullptr;
|
|
|
|
// GPU memory reporting is not available before Windows 7
|
|
if (!IsWin7OrLater())
|
|
return NS_OK;
|
|
|
|
if ((gdi32Handle = LoadLibrary(TEXT("gdi32.dll"))))
|
|
queryD3DKMTStatistics = (PFND3DKMTQS)GetProcAddress(gdi32Handle, "D3DKMTQueryStatistics");
|
|
|
|
if (queryD3DKMTStatistics && GetDXGIAdapter(&DXGIAdapter)) {
|
|
// Most of this block is understood thanks to wj32's work on Process Hacker
|
|
|
|
DXGI_ADAPTER_DESC adapterDesc;
|
|
D3DKMTQS queryStatistics;
|
|
|
|
DXGIAdapter->GetDesc(&adapterDesc);
|
|
DXGIAdapter->Release();
|
|
|
|
memset(&queryStatistics, 0, sizeof(D3DKMTQS));
|
|
queryStatistics.Type = D3DKMTQS_PROCESS;
|
|
queryStatistics.AdapterLuid = adapterDesc.AdapterLuid;
|
|
queryStatistics.hProcess = ProcessHandle;
|
|
if (NT_SUCCESS(queryD3DKMTStatistics(&queryStatistics))) {
|
|
committedBytesUsed = queryStatistics.QueryResult.ProcessInfo.SystemMemory.BytesAllocated;
|
|
}
|
|
|
|
memset(&queryStatistics, 0, sizeof(D3DKMTQS));
|
|
queryStatistics.Type = D3DKMTQS_ADAPTER;
|
|
queryStatistics.AdapterLuid = adapterDesc.AdapterLuid;
|
|
if (NT_SUCCESS(queryD3DKMTStatistics(&queryStatistics))) {
|
|
ULONG i;
|
|
ULONG segmentCount = queryStatistics.QueryResult.AdapterInfo.NbSegments;
|
|
|
|
for (i = 0; i < segmentCount; i++) {
|
|
memset(&queryStatistics, 0, sizeof(D3DKMTQS));
|
|
queryStatistics.Type = D3DKMTQS_SEGMENT;
|
|
queryStatistics.AdapterLuid = adapterDesc.AdapterLuid;
|
|
queryStatistics.QuerySegment.SegmentId = i;
|
|
|
|
if (NT_SUCCESS(queryD3DKMTStatistics(&queryStatistics))) {
|
|
bool aperture;
|
|
|
|
// SegmentInformation has a different definition in Win7 than later versions
|
|
if (!IsWin8OrLater())
|
|
aperture = queryStatistics.QueryResult.SegmentInfoWin7.Aperture;
|
|
else
|
|
aperture = queryStatistics.QueryResult.SegmentInfoWin8.Aperture;
|
|
|
|
memset(&queryStatistics, 0, sizeof(D3DKMTQS));
|
|
queryStatistics.Type = D3DKMTQS_PROCESS_SEGMENT;
|
|
queryStatistics.AdapterLuid = adapterDesc.AdapterLuid;
|
|
queryStatistics.hProcess = ProcessHandle;
|
|
queryStatistics.QueryProcessSegment.SegmentId = i;
|
|
if (NT_SUCCESS(queryD3DKMTStatistics(&queryStatistics))) {
|
|
ULONGLONG bytesCommitted;
|
|
if (!IsWin8OrLater())
|
|
bytesCommitted = queryStatistics.QueryResult.ProcessSegmentInfo.Win7.BytesCommitted;
|
|
else
|
|
bytesCommitted = queryStatistics.QueryResult.ProcessSegmentInfo.Win8.BytesCommitted;
|
|
if (aperture)
|
|
sharedBytesUsed += bytesCommitted;
|
|
else
|
|
dedicatedBytesUsed += bytesCommitted;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
FreeLibrary(gdi32Handle);
|
|
|
|
MOZ_COLLECT_REPORT(
|
|
"gpu-committed", KIND_OTHER, UNITS_BYTES, committedBytesUsed,
|
|
"Memory committed by the Windows graphics system.");
|
|
|
|
MOZ_COLLECT_REPORT(
|
|
"gpu-dedicated", KIND_OTHER, UNITS_BYTES,
|
|
dedicatedBytesUsed,
|
|
"Out-of-process memory allocated for this process in a physical "
|
|
"GPU adapter's memory.");
|
|
|
|
MOZ_COLLECT_REPORT(
|
|
"gpu-shared", KIND_OTHER, UNITS_BYTES,
|
|
sharedBytesUsed,
|
|
"In-process memory that is shared with the GPU.");
|
|
|
|
return NS_OK;
|
|
}
|
|
};
|
|
|
|
NS_IMPL_ISUPPORTS(GPUAdapterReporter, nsIMemoryReporter)
|
|
|
|
Atomic<size_t> gfxWindowsPlatform::sD3D11SharedTextures;
|
|
Atomic<size_t> gfxWindowsPlatform::sD3D9SharedTextures;
|
|
|
|
class D3DSharedTexturesReporter final : public nsIMemoryReporter
|
|
{
|
|
~D3DSharedTexturesReporter() {}
|
|
|
|
public:
|
|
NS_DECL_ISUPPORTS
|
|
|
|
NS_IMETHOD CollectReports(nsIHandleReportCallback *aHandleReport,
|
|
nsISupports* aData, bool aAnonymize) override
|
|
{
|
|
if (gfxWindowsPlatform::sD3D11SharedTextures > 0) {
|
|
MOZ_COLLECT_REPORT(
|
|
"d3d11-shared-textures", KIND_OTHER, UNITS_BYTES,
|
|
gfxWindowsPlatform::sD3D11SharedTextures,
|
|
"D3D11 shared textures.");
|
|
}
|
|
|
|
if (gfxWindowsPlatform::sD3D9SharedTextures > 0) {
|
|
MOZ_COLLECT_REPORT(
|
|
"d3d9-shared-textures", KIND_OTHER, UNITS_BYTES,
|
|
gfxWindowsPlatform::sD3D9SharedTextures,
|
|
"D3D9 shared textures.");
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
};
|
|
|
|
NS_IMPL_ISUPPORTS(D3DSharedTexturesReporter, nsIMemoryReporter)
|
|
|
|
gfxWindowsPlatform::gfxWindowsPlatform()
|
|
: mRenderMode(RENDER_GDI)
|
|
{
|
|
mUseClearTypeForDownloadableFonts = UNINITIALIZED_VALUE;
|
|
mUseClearTypeAlways = UNINITIALIZED_VALUE;
|
|
|
|
/*
|
|
* Initialize COM
|
|
*/
|
|
CoInitialize(nullptr);
|
|
|
|
RegisterStrongMemoryReporter(new GfxD2DVramReporter());
|
|
RegisterStrongMemoryReporter(new GPUAdapterReporter());
|
|
RegisterStrongMemoryReporter(new D3DSharedTexturesReporter());
|
|
}
|
|
|
|
gfxWindowsPlatform::~gfxWindowsPlatform()
|
|
{
|
|
mozilla::gfx::Factory::D2DCleanup();
|
|
|
|
DeviceManagerD3D9::Shutdown();
|
|
DeviceManagerDx::Shutdown();
|
|
|
|
/*
|
|
* Uninitialize COM
|
|
*/
|
|
CoUninitialize();
|
|
}
|
|
|
|
static void
|
|
UpdateANGLEConfig()
|
|
{
|
|
if (!gfxConfig::IsEnabled(Feature::D3D11_COMPOSITING)) {
|
|
gfxConfig::Disable(Feature::D3D11_HW_ANGLE, FeatureStatus::Disabled, "D3D11 compositing is disabled");
|
|
}
|
|
}
|
|
|
|
void
|
|
gfxWindowsPlatform::InitAcceleration()
|
|
{
|
|
gfxPlatform::InitAcceleration();
|
|
|
|
// Set up the D3D11 feature levels we can ask for.
|
|
if (IsWin8OrLater()) {
|
|
mFeatureLevels.AppendElement(D3D_FEATURE_LEVEL_11_1);
|
|
}
|
|
mFeatureLevels.AppendElement(D3D_FEATURE_LEVEL_11_0);
|
|
mFeatureLevels.AppendElement(D3D_FEATURE_LEVEL_10_1);
|
|
mFeatureLevels.AppendElement(D3D_FEATURE_LEVEL_10_0);
|
|
mFeatureLevels.AppendElement(D3D_FEATURE_LEVEL_9_3);
|
|
|
|
DeviceManagerDx::Init();
|
|
DeviceManagerD3D9::Init();
|
|
|
|
InitializeConfig();
|
|
InitializeDevices();
|
|
UpdateANGLEConfig();
|
|
UpdateRenderMode();
|
|
|
|
// If we have Skia and we didn't init dwrite already, do it now.
|
|
if (!mDWriteFactory && GetDefaultContentBackend() == BackendType::SKIA) {
|
|
InitDWriteSupport();
|
|
}
|
|
|
|
// CanUseHardwareVideoDecoding depends on DeviceManagerDx state,
|
|
// so update the cached value now.
|
|
UpdateCanUseHardwareVideoDecoding();
|
|
}
|
|
|
|
bool
|
|
gfxWindowsPlatform::CanUseHardwareVideoDecoding()
|
|
{
|
|
DeviceManagerDx* dm = DeviceManagerDx::Get();
|
|
if (!dm) {
|
|
return false;
|
|
}
|
|
if (!gfxPrefs::LayersPreferD3D9() && !dm->TextureSharingWorks()) {
|
|
return false;
|
|
}
|
|
return !dm->IsWARP() && gfxPlatform::CanUseHardwareVideoDecoding();
|
|
}
|
|
|
|
bool
|
|
gfxWindowsPlatform::InitDWriteSupport()
|
|
{
|
|
if (!IsVistaOrLater()) {
|
|
return false;
|
|
}
|
|
|
|
// DWrite is only supported on Windows 7 with the platform update and higher.
|
|
// We check this by seeing if D2D1 support is available.
|
|
if (!Factory::SupportsD2D1()) {
|
|
return false;
|
|
}
|
|
|
|
decltype(DWriteCreateFactory)* createDWriteFactory = (decltype(DWriteCreateFactory)*)
|
|
GetProcAddress(LoadLibraryW(L"dwrite.dll"), "DWriteCreateFactory");
|
|
if (!createDWriteFactory) {
|
|
return false;
|
|
}
|
|
|
|
// I need a direct pointer to be able to cast to IUnknown**, I also need to
|
|
// remember to release this because the nsRefPtr will AddRef it.
|
|
RefPtr<IDWriteFactory> factory;
|
|
HRESULT hr = createDWriteFactory(
|
|
DWRITE_FACTORY_TYPE_SHARED,
|
|
__uuidof(IDWriteFactory),
|
|
(IUnknown **)((IDWriteFactory **)getter_AddRefs(factory)));
|
|
if (FAILED(hr) || !factory) {
|
|
return false;
|
|
}
|
|
|
|
mDWriteFactory = factory;
|
|
Factory::SetDWriteFactory(mDWriteFactory);
|
|
|
|
SetupClearTypeParams();
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
gfxWindowsPlatform::HandleDeviceReset()
|
|
{
|
|
DeviceResetReason resetReason = DeviceResetReason::OK;
|
|
if (!DidRenderingDeviceReset(&resetReason)) {
|
|
return false;
|
|
}
|
|
|
|
// Remove devices and adapters.
|
|
DeviceManagerDx::Get()->ResetDevices();
|
|
|
|
imgLoader::NormalLoader()->ClearCache(true);
|
|
imgLoader::NormalLoader()->ClearCache(false);
|
|
imgLoader::PrivateBrowsingLoader()->ClearCache(true);
|
|
imgLoader::PrivateBrowsingLoader()->ClearCache(false);
|
|
gfxAlphaBoxBlur::ShutdownBlurCache();
|
|
|
|
if (XRE_IsContentProcess()) {
|
|
// Fetch updated device parameters.
|
|
FetchAndImportContentDeviceData();
|
|
UpdateANGLEConfig();
|
|
}
|
|
|
|
InitializeDevices();
|
|
UpdateANGLEConfig();
|
|
BumpDeviceCounter();
|
|
return true;
|
|
}
|
|
|
|
void
|
|
gfxWindowsPlatform::UpdateBackendPrefs()
|
|
{
|
|
uint32_t canvasMask = BackendTypeBit(BackendType::CAIRO);
|
|
uint32_t contentMask = BackendTypeBit(BackendType::CAIRO);
|
|
BackendType defaultBackend = BackendType::CAIRO;
|
|
if (gfxConfig::IsEnabled(Feature::DIRECT2D) && Factory::GetD2D1Device()) {
|
|
contentMask |= BackendTypeBit(BackendType::DIRECT2D1_1);
|
|
canvasMask |= BackendTypeBit(BackendType::DIRECT2D1_1);
|
|
defaultBackend = BackendType::DIRECT2D1_1;
|
|
} else {
|
|
canvasMask |= BackendTypeBit(BackendType::SKIA);
|
|
}
|
|
contentMask |= BackendTypeBit(BackendType::SKIA);
|
|
InitBackendPrefs(canvasMask, defaultBackend, contentMask, defaultBackend);
|
|
}
|
|
|
|
bool
|
|
gfxWindowsPlatform::IsDirect2DBackend()
|
|
{
|
|
return GetDefaultContentBackend() == BackendType::DIRECT2D1_1;
|
|
}
|
|
|
|
void
|
|
gfxWindowsPlatform::UpdateRenderMode()
|
|
{
|
|
bool didReset = HandleDeviceReset();
|
|
|
|
UpdateBackendPrefs();
|
|
|
|
if (didReset) {
|
|
mScreenReferenceDrawTarget =
|
|
CreateOffscreenContentDrawTarget(IntSize(1, 1), SurfaceFormat::B8G8R8A8);
|
|
if (!mScreenReferenceDrawTarget) {
|
|
gfxCriticalNote << "Failed to update reference draw target after device reset"
|
|
<< ", D3D11 device:" << hexa(Factory::GetDirect3D11Device())
|
|
<< ", D3D11 status:" << FeatureStatusToString(gfxConfig::GetValue(Feature::D3D11_COMPOSITING))
|
|
<< ", D2D1 device:" << hexa(Factory::GetD2D1Device())
|
|
<< ", D2D1 status:" << FeatureStatusToString(gfxConfig::GetValue(Feature::DIRECT2D))
|
|
<< ", content:" << int(GetDefaultContentBackend())
|
|
<< ", compositor:" << int(GetCompositorBackend());
|
|
MOZ_CRASH("GFX: Failed to update reference draw target after device reset");
|
|
}
|
|
}
|
|
}
|
|
|
|
mozilla::gfx::BackendType
|
|
gfxWindowsPlatform::GetContentBackendFor(mozilla::layers::LayersBackend aLayers)
|
|
{
|
|
mozilla::gfx::BackendType defaultBackend = gfxPlatform::GetDefaultContentBackend();
|
|
if (aLayers == LayersBackend::LAYERS_D3D11) {
|
|
return defaultBackend;
|
|
}
|
|
|
|
if (defaultBackend == BackendType::DIRECT2D1_1) {
|
|
// We can't have D2D without D3D11 layers, so fallback to Cairo.
|
|
return BackendType::CAIRO;
|
|
}
|
|
|
|
// Otherwise we have some non-accelerated backend and that's ok.
|
|
return defaultBackend;
|
|
}
|
|
|
|
gfxPlatformFontList*
|
|
gfxWindowsPlatform::CreatePlatformFontList()
|
|
{
|
|
gfxPlatformFontList *pfl;
|
|
|
|
// bug 630201 - older pre-RTM versions of Direct2D/DirectWrite cause odd
|
|
// crashers so blacklist them altogether
|
|
if (IsNotWin7PreRTM() && GetDWriteFactory()) {
|
|
pfl = new gfxDWriteFontList();
|
|
if (NS_SUCCEEDED(pfl->InitFontList())) {
|
|
return pfl;
|
|
}
|
|
// DWrite font initialization failed! Don't know why this would happen,
|
|
// but apparently it can - see bug 594865.
|
|
// So we're going to fall back to GDI fonts & rendering.
|
|
gfxPlatformFontList::Shutdown();
|
|
DisableD2D(FeatureStatus::Failed, "Failed to initialize fonts",
|
|
NS_LITERAL_CSTRING("FEATURE_FAILURE_FONT_FAIL"));
|
|
}
|
|
|
|
pfl = new gfxGDIFontList();
|
|
|
|
if (NS_SUCCEEDED(pfl->InitFontList())) {
|
|
return pfl;
|
|
}
|
|
|
|
gfxPlatformFontList::Shutdown();
|
|
return nullptr;
|
|
}
|
|
|
|
// This function will permanently disable D2D for the session. It's intended to
|
|
// be used when, after initially chosing to use Direct2D, we encounter a
|
|
// scenario we can't support.
|
|
//
|
|
// This is called during gfxPlatform::Init() so at this point there should be no
|
|
// DrawTargetD2D/1 instances.
|
|
void
|
|
gfxWindowsPlatform::DisableD2D(FeatureStatus aStatus, const char* aMessage,
|
|
const nsACString& aFailureId)
|
|
{
|
|
gfxConfig::SetFailed(Feature::DIRECT2D, aStatus, aMessage, aFailureId);
|
|
Factory::SetDirect3D11Device(nullptr);
|
|
UpdateBackendPrefs();
|
|
}
|
|
|
|
already_AddRefed<gfxASurface>
|
|
gfxWindowsPlatform::CreateOffscreenSurface(const IntSize& aSize,
|
|
gfxImageFormat aFormat)
|
|
{
|
|
if (!Factory::AllowedSurfaceSize(aSize)) {
|
|
return nullptr;
|
|
}
|
|
|
|
RefPtr<gfxASurface> surf = nullptr;
|
|
|
|
#ifdef CAIRO_HAS_WIN32_SURFACE
|
|
if (mRenderMode == RENDER_GDI || mRenderMode == RENDER_DIRECT2D)
|
|
surf = new gfxWindowsSurface(aSize, aFormat);
|
|
#endif
|
|
|
|
if (!surf || surf->CairoStatus()) {
|
|
surf = new gfxImageSurface(aSize, aFormat);
|
|
}
|
|
|
|
return surf.forget();
|
|
}
|
|
|
|
already_AddRefed<ScaledFont>
|
|
gfxWindowsPlatform::GetScaledFontForFont(DrawTarget* aTarget, gfxFont *aFont)
|
|
{
|
|
if (aFont->GetType() == gfxFont::FONT_TYPE_DWRITE) {
|
|
gfxDWriteFont *font = static_cast<gfxDWriteFont*>(aFont);
|
|
|
|
NativeFont nativeFont;
|
|
nativeFont.mType = NativeFontType::DWRITE_FONT_FACE;
|
|
nativeFont.mFont = font->GetFontFace();
|
|
|
|
if (aTarget->GetBackendType() == BackendType::CAIRO) {
|
|
return Factory::CreateScaledFontWithCairo(nativeFont,
|
|
font->GetAdjustedSize(),
|
|
font->GetCairoScaledFont());
|
|
}
|
|
|
|
return Factory::CreateScaledFontForNativeFont(nativeFont,
|
|
font->GetAdjustedSize());
|
|
}
|
|
|
|
NS_ASSERTION(aFont->GetType() == gfxFont::FONT_TYPE_GDI,
|
|
"Fonts on windows should be GDI or DWrite!");
|
|
|
|
NativeFont nativeFont;
|
|
nativeFont.mType = NativeFontType::GDI_FONT_FACE;
|
|
LOGFONT lf;
|
|
GetObject(static_cast<gfxGDIFont*>(aFont)->GetHFONT(), sizeof(LOGFONT), &lf);
|
|
nativeFont.mFont = &lf;
|
|
|
|
if (aTarget->GetBackendType() == BackendType::CAIRO) {
|
|
return Factory::CreateScaledFontWithCairo(nativeFont,
|
|
aFont->GetAdjustedSize(),
|
|
aFont->GetCairoScaledFont());
|
|
}
|
|
|
|
return Factory::CreateScaledFontForNativeFont(nativeFont, aFont->GetAdjustedSize());
|
|
}
|
|
|
|
static const char kFontAparajita[] = "Aparajita";
|
|
static const char kFontArabicTypesetting[] = "Arabic Typesetting";
|
|
static const char kFontArial[] = "Arial";
|
|
static const char kFontArialUnicodeMS[] = "Arial Unicode MS";
|
|
static const char kFontCambria[] = "Cambria";
|
|
static const char kFontCambriaMath[] = "Cambria Math";
|
|
static const char kFontEbrima[] = "Ebrima";
|
|
static const char kFontEstrangeloEdessa[] = "Estrangelo Edessa";
|
|
static const char kFontEuphemia[] = "Euphemia";
|
|
static const char kFontGabriola[] = "Gabriola";
|
|
static const char kFontJavaneseText[] = "Javanese Text";
|
|
static const char kFontKhmerUI[] = "Khmer UI";
|
|
static const char kFontLaoUI[] = "Lao UI";
|
|
static const char kFontLeelawadeeUI[] = "Leelawadee UI";
|
|
static const char kFontLucidaSansUnicode[] = "Lucida Sans Unicode";
|
|
static const char kFontMVBoli[] = "MV Boli";
|
|
static const char kFontMalgunGothic[] = "Malgun Gothic";
|
|
static const char kFontMicrosoftJhengHei[] = "Microsoft JhengHei";
|
|
static const char kFontMicrosoftNewTaiLue[] = "Microsoft New Tai Lue";
|
|
static const char kFontMicrosoftPhagsPa[] = "Microsoft PhagsPa";
|
|
static const char kFontMicrosoftTaiLe[] = "Microsoft Tai Le";
|
|
static const char kFontMicrosoftUighur[] = "Microsoft Uighur";
|
|
static const char kFontMicrosoftYaHei[] = "Microsoft YaHei";
|
|
static const char kFontMicrosoftYiBaiti[] = "Microsoft Yi Baiti";
|
|
static const char kFontMeiryo[] = "Meiryo";
|
|
static const char kFontMongolianBaiti[] = "Mongolian Baiti";
|
|
static const char kFontMyanmarText[] = "Myanmar Text";
|
|
static const char kFontNirmalaUI[] = "Nirmala UI";
|
|
static const char kFontNyala[] = "Nyala";
|
|
static const char kFontPlantagenetCherokee[] = "Plantagenet Cherokee";
|
|
static const char kFontSegoeUI[] = "Segoe UI";
|
|
static const char kFontSegoeUIEmoji[] = "Segoe UI Emoji";
|
|
static const char kFontSegoeUISymbol[] = "Segoe UI Symbol";
|
|
static const char kFontSylfaen[] = "Sylfaen";
|
|
static const char kFontTraditionalArabic[] = "Traditional Arabic";
|
|
static const char kFontTwemojiMozilla[] = "Twemoji Mozilla";
|
|
static const char kFontUtsaah[] = "Utsaah";
|
|
static const char kFontYuGothic[] = "Yu Gothic";
|
|
|
|
void
|
|
gfxWindowsPlatform::GetCommonFallbackFonts(uint32_t aCh, uint32_t aNextCh,
|
|
Script aRunScript,
|
|
nsTArray<const char*>& aFontList)
|
|
{
|
|
EmojiPresentation emoji = GetEmojiPresentation(aCh);
|
|
if (emoji != EmojiPresentation::TextOnly) {
|
|
if (aNextCh == kVariationSelector16 ||
|
|
(aNextCh != kVariationSelector15 &&
|
|
emoji == EmojiPresentation::EmojiDefault)) {
|
|
// if char is followed by VS16, try for a color emoji glyph
|
|
// XXX: For Win8+ native, aFontList.AppendElement(kFontSegoeUIEmoji);
|
|
aFontList.AppendElement(kFontTwemojiMozilla);
|
|
}
|
|
}
|
|
|
|
// Arial is used as the default fallback for system fallback
|
|
aFontList.AppendElement(kFontArial);
|
|
|
|
if (!IS_IN_BMP(aCh)) {
|
|
uint32_t p = aCh >> 16;
|
|
if (p == 1) { // SMP plane
|
|
aFontList.AppendElement(kFontSegoeUISymbol);
|
|
aFontList.AppendElement(kFontEbrima);
|
|
aFontList.AppendElement(kFontNirmalaUI);
|
|
aFontList.AppendElement(kFontCambriaMath);
|
|
}
|
|
} else {
|
|
uint32_t b = (aCh >> 8) & 0xff;
|
|
|
|
switch (b) {
|
|
case 0x05:
|
|
aFontList.AppendElement(kFontEstrangeloEdessa);
|
|
aFontList.AppendElement(kFontCambria);
|
|
break;
|
|
case 0x06:
|
|
aFontList.AppendElement(kFontMicrosoftUighur);
|
|
break;
|
|
case 0x07:
|
|
aFontList.AppendElement(kFontEstrangeloEdessa);
|
|
aFontList.AppendElement(kFontMVBoli);
|
|
aFontList.AppendElement(kFontEbrima);
|
|
break;
|
|
case 0x09:
|
|
aFontList.AppendElement(kFontNirmalaUI);
|
|
aFontList.AppendElement(kFontUtsaah);
|
|
aFontList.AppendElement(kFontAparajita);
|
|
break;
|
|
case 0x0a:
|
|
case 0x0b:
|
|
case 0x0c:
|
|
case 0x0d:
|
|
aFontList.AppendElement(kFontNirmalaUI);
|
|
break;
|
|
case 0x0e:
|
|
aFontList.AppendElement(kFontLaoUI);
|
|
aFontList.AppendElement(kFontLeelawadeeUI);
|
|
break;
|
|
case 0x10:
|
|
aFontList.AppendElement(kFontMyanmarText);
|
|
break;
|
|
case 0x11:
|
|
aFontList.AppendElement(kFontMalgunGothic);
|
|
break;
|
|
case 0x12:
|
|
case 0x13:
|
|
aFontList.AppendElement(kFontNyala);
|
|
aFontList.AppendElement(kFontPlantagenetCherokee);
|
|
break;
|
|
case 0x14:
|
|
case 0x15:
|
|
case 0x16:
|
|
aFontList.AppendElement(kFontEuphemia);
|
|
aFontList.AppendElement(kFontSegoeUISymbol);
|
|
break;
|
|
case 0x17:
|
|
aFontList.AppendElement(kFontKhmerUI);
|
|
aFontList.AppendElement(kFontLeelawadeeUI);
|
|
break;
|
|
case 0x18: // Mongolian
|
|
aFontList.AppendElement(kFontMongolianBaiti);
|
|
aFontList.AppendElement(kFontEuphemia);
|
|
break;
|
|
case 0x19:
|
|
aFontList.AppendElement(kFontMicrosoftTaiLe);
|
|
aFontList.AppendElement(kFontMicrosoftNewTaiLue);
|
|
aFontList.AppendElement(kFontKhmerUI);
|
|
aFontList.AppendElement(kFontLeelawadeeUI);
|
|
break;
|
|
case 0x1a:
|
|
aFontList.AppendElement(kFontLeelawadeeUI);
|
|
break;
|
|
case 0x1c:
|
|
aFontList.AppendElement(kFontNirmalaUI);
|
|
break;
|
|
case 0x20: // Symbol ranges
|
|
case 0x21:
|
|
case 0x22:
|
|
case 0x23:
|
|
case 0x24:
|
|
case 0x25:
|
|
case 0x26:
|
|
case 0x27:
|
|
case 0x29:
|
|
case 0x2a:
|
|
case 0x2b:
|
|
case 0x2c:
|
|
aFontList.AppendElement(kFontSegoeUI);
|
|
aFontList.AppendElement(kFontSegoeUISymbol);
|
|
aFontList.AppendElement(kFontCambria);
|
|
aFontList.AppendElement(kFontMeiryo);
|
|
aFontList.AppendElement(kFontArial);
|
|
aFontList.AppendElement(kFontLucidaSansUnicode);
|
|
aFontList.AppendElement(kFontEbrima);
|
|
break;
|
|
case 0x2d:
|
|
case 0x2e:
|
|
case 0x2f:
|
|
aFontList.AppendElement(kFontEbrima);
|
|
aFontList.AppendElement(kFontNyala);
|
|
aFontList.AppendElement(kFontSegoeUI);
|
|
aFontList.AppendElement(kFontSegoeUISymbol);
|
|
aFontList.AppendElement(kFontMeiryo);
|
|
break;
|
|
case 0x28: // Braille
|
|
aFontList.AppendElement(kFontSegoeUISymbol);
|
|
break;
|
|
case 0x30:
|
|
case 0x31:
|
|
aFontList.AppendElement(kFontMicrosoftYaHei);
|
|
break;
|
|
case 0x32:
|
|
aFontList.AppendElement(kFontMalgunGothic);
|
|
break;
|
|
case 0x4d:
|
|
aFontList.AppendElement(kFontSegoeUISymbol);
|
|
break;
|
|
case 0x9f:
|
|
aFontList.AppendElement(kFontMicrosoftYaHei);
|
|
aFontList.AppendElement(kFontYuGothic);
|
|
break;
|
|
case 0xa0: // Yi
|
|
case 0xa1:
|
|
case 0xa2:
|
|
case 0xa3:
|
|
case 0xa4:
|
|
aFontList.AppendElement(kFontMicrosoftYiBaiti);
|
|
aFontList.AppendElement(kFontSegoeUI);
|
|
break;
|
|
case 0xa5:
|
|
case 0xa6:
|
|
case 0xa7:
|
|
aFontList.AppendElement(kFontEbrima);
|
|
aFontList.AppendElement(kFontSegoeUI);
|
|
aFontList.AppendElement(kFontCambriaMath);
|
|
break;
|
|
case 0xa8:
|
|
aFontList.AppendElement(kFontMicrosoftPhagsPa);
|
|
aFontList.AppendElement(kFontNirmalaUI);
|
|
break;
|
|
case 0xa9:
|
|
aFontList.AppendElement(kFontMalgunGothic);
|
|
aFontList.AppendElement(kFontJavaneseText);
|
|
aFontList.AppendElement(kFontLeelawadeeUI);
|
|
break;
|
|
case 0xaa:
|
|
aFontList.AppendElement(kFontMyanmarText);
|
|
break;
|
|
case 0xab:
|
|
aFontList.AppendElement(kFontEbrima);
|
|
aFontList.AppendElement(kFontNyala);
|
|
break;
|
|
case 0xd7:
|
|
aFontList.AppendElement(kFontMalgunGothic);
|
|
break;
|
|
case 0xfb:
|
|
aFontList.AppendElement(kFontMicrosoftUighur);
|
|
aFontList.AppendElement(kFontGabriola);
|
|
aFontList.AppendElement(kFontSylfaen);
|
|
break;
|
|
case 0xfc:
|
|
case 0xfd:
|
|
aFontList.AppendElement(kFontTraditionalArabic);
|
|
aFontList.AppendElement(kFontArabicTypesetting);
|
|
break;
|
|
case 0xfe:
|
|
aFontList.AppendElement(kFontTraditionalArabic);
|
|
aFontList.AppendElement(kFontMicrosoftJhengHei);
|
|
break;
|
|
case 0xff:
|
|
aFontList.AppendElement(kFontMicrosoftJhengHei);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Arial Unicode MS has lots of glyphs for obscure characters,
|
|
// use it as a last resort
|
|
aFontList.AppendElement(kFontArialUnicodeMS);
|
|
}
|
|
|
|
gfxFontGroup *
|
|
gfxWindowsPlatform::CreateFontGroup(const FontFamilyList& aFontFamilyList,
|
|
const gfxFontStyle *aStyle,
|
|
gfxTextPerfMetrics* aTextPerf,
|
|
gfxUserFontSet *aUserFontSet,
|
|
gfxFloat aDevToCssSize)
|
|
{
|
|
return new gfxFontGroup(aFontFamilyList, aStyle, aTextPerf,
|
|
aUserFontSet, aDevToCssSize);
|
|
}
|
|
|
|
bool
|
|
gfxWindowsPlatform::IsFontFormatSupported(nsIURI *aFontURI, uint32_t aFormatFlags)
|
|
{
|
|
// check for strange format flags
|
|
NS_ASSERTION(!(aFormatFlags & gfxUserFontSet::FLAG_FORMAT_NOT_USED),
|
|
"strange font format hint set");
|
|
|
|
// accept supported formats
|
|
if (aFormatFlags & gfxUserFontSet::FLAG_FORMATS_COMMON) {
|
|
return true;
|
|
}
|
|
|
|
// reject all other formats, known and unknown
|
|
if (aFormatFlags != 0) {
|
|
return false;
|
|
}
|
|
|
|
// no format hint set, need to look at data
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
gfxWindowsPlatform::DidRenderingDeviceReset(DeviceResetReason* aResetReason)
|
|
{
|
|
DeviceManagerDx* dm = DeviceManagerDx::Get();
|
|
if (!dm) {
|
|
return false;
|
|
}
|
|
return dm->HasDeviceReset(aResetReason);
|
|
}
|
|
|
|
void
|
|
gfxWindowsPlatform::CompositorUpdated()
|
|
{
|
|
DeviceManagerDx::Get()->ForceDeviceReset(ForcedDeviceResetReason::COMPOSITOR_UPDATED);
|
|
UpdateRenderMode();
|
|
}
|
|
|
|
BOOL CALLBACK
|
|
InvalidateWindowForDeviceReset(HWND aWnd, LPARAM aMsg)
|
|
{
|
|
RedrawWindow(aWnd, nullptr, nullptr,
|
|
RDW_INVALIDATE|RDW_INTERNALPAINT|RDW_FRAME);
|
|
return TRUE;
|
|
}
|
|
|
|
void
|
|
gfxWindowsPlatform::SchedulePaintIfDeviceReset()
|
|
{
|
|
PROFILER_LABEL_FUNC(js::ProfileEntry::Category::GRAPHICS);
|
|
|
|
DeviceResetReason resetReason = DeviceResetReason::OK;
|
|
if (!DidRenderingDeviceReset(&resetReason)) {
|
|
return;
|
|
}
|
|
|
|
gfxCriticalNote << "(gfxWindowsPlatform) Detected device reset: " << (int)resetReason;
|
|
|
|
// Trigger an ::OnPaint for each window.
|
|
::EnumThreadWindows(GetCurrentThreadId(),
|
|
InvalidateWindowForDeviceReset,
|
|
0);
|
|
|
|
gfxCriticalNote << "(gfxWindowsPlatform) Finished device reset.";
|
|
}
|
|
|
|
void
|
|
gfxWindowsPlatform::GetPlatformCMSOutputProfile(void* &mem, size_t &mem_size)
|
|
{
|
|
WCHAR str[MAX_PATH];
|
|
DWORD size = MAX_PATH;
|
|
BOOL res;
|
|
|
|
mem = nullptr;
|
|
mem_size = 0;
|
|
|
|
HDC dc = GetDC(nullptr);
|
|
if (!dc)
|
|
return;
|
|
|
|
MOZ_SEH_TRY {
|
|
res = GetICMProfileW(dc, &size, (LPWSTR)&str);
|
|
} MOZ_SEH_EXCEPT(GetExceptionCode() == EXCEPTION_ILLEGAL_INSTRUCTION) {
|
|
res = FALSE;
|
|
}
|
|
|
|
ReleaseDC(nullptr, dc);
|
|
if (!res)
|
|
return;
|
|
|
|
#ifdef _WIN32
|
|
qcms_data_from_unicode_path(str, &mem, &mem_size);
|
|
|
|
#ifdef DEBUG_tor
|
|
if (mem_size > 0)
|
|
fprintf(stderr,
|
|
"ICM profile read from %s successfully\n",
|
|
NS_ConvertUTF16toUTF8(str).get());
|
|
#endif // DEBUG_tor
|
|
#endif // _WIN32
|
|
}
|
|
|
|
bool
|
|
gfxWindowsPlatform::UseClearTypeForDownloadableFonts()
|
|
{
|
|
if (mUseClearTypeForDownloadableFonts == UNINITIALIZED_VALUE) {
|
|
mUseClearTypeForDownloadableFonts = Preferences::GetBool(GFX_DOWNLOADABLE_FONTS_USE_CLEARTYPE, true);
|
|
}
|
|
|
|
return mUseClearTypeForDownloadableFonts;
|
|
}
|
|
|
|
bool
|
|
gfxWindowsPlatform::UseClearTypeAlways()
|
|
{
|
|
if (mUseClearTypeAlways == UNINITIALIZED_VALUE) {
|
|
mUseClearTypeAlways = Preferences::GetBool(GFX_USE_CLEARTYPE_ALWAYS, false);
|
|
}
|
|
|
|
return mUseClearTypeAlways;
|
|
}
|
|
|
|
void
|
|
gfxWindowsPlatform::GetDLLVersion(char16ptr_t aDLLPath, nsAString& aVersion)
|
|
{
|
|
DWORD versInfoSize, vers[4] = {0};
|
|
// version info not available case
|
|
aVersion.AssignLiteral(u"0.0.0.0");
|
|
versInfoSize = GetFileVersionInfoSizeW(aDLLPath, nullptr);
|
|
AutoTArray<BYTE,512> versionInfo;
|
|
|
|
if (versInfoSize == 0 ||
|
|
!versionInfo.AppendElements(uint32_t(versInfoSize)))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!GetFileVersionInfoW(aDLLPath, 0, versInfoSize,
|
|
LPBYTE(versionInfo.Elements())))
|
|
{
|
|
return;
|
|
}
|
|
|
|
UINT len = 0;
|
|
VS_FIXEDFILEINFO *fileInfo = nullptr;
|
|
if (!VerQueryValue(LPBYTE(versionInfo.Elements()), TEXT("\\"),
|
|
(LPVOID *)&fileInfo, &len) ||
|
|
len == 0 ||
|
|
fileInfo == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
DWORD fileVersMS = fileInfo->dwFileVersionMS;
|
|
DWORD fileVersLS = fileInfo->dwFileVersionLS;
|
|
|
|
vers[0] = HIWORD(fileVersMS);
|
|
vers[1] = LOWORD(fileVersMS);
|
|
vers[2] = HIWORD(fileVersLS);
|
|
vers[3] = LOWORD(fileVersLS);
|
|
|
|
char buf[256];
|
|
SprintfLiteral(buf, "%u.%u.%u.%u", vers[0], vers[1], vers[2], vers[3]);
|
|
aVersion.Assign(NS_ConvertUTF8toUTF16(buf));
|
|
}
|
|
|
|
void
|
|
gfxWindowsPlatform::GetCleartypeParams(nsTArray<ClearTypeParameterInfo>& aParams)
|
|
{
|
|
HKEY hKey, subKey;
|
|
DWORD i, rv, size, type;
|
|
WCHAR displayName[256], subkeyName[256];
|
|
|
|
aParams.Clear();
|
|
|
|
// construct subkeys based on HKLM subkeys, assume they are same for HKCU
|
|
rv = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
|
|
L"Software\\Microsoft\\Avalon.Graphics",
|
|
0, KEY_READ, &hKey);
|
|
|
|
if (rv != ERROR_SUCCESS) {
|
|
return;
|
|
}
|
|
|
|
// enumerate over subkeys
|
|
for (i = 0, rv = ERROR_SUCCESS; rv != ERROR_NO_MORE_ITEMS; i++) {
|
|
size = ArrayLength(displayName);
|
|
rv = RegEnumKeyExW(hKey, i, displayName, &size,
|
|
nullptr, nullptr, nullptr, nullptr);
|
|
if (rv != ERROR_SUCCESS) {
|
|
continue;
|
|
}
|
|
|
|
ClearTypeParameterInfo ctinfo;
|
|
ctinfo.displayName.Assign(displayName);
|
|
|
|
DWORD subrv, value;
|
|
bool foundData = false;
|
|
|
|
swprintf_s(subkeyName, ArrayLength(subkeyName),
|
|
L"Software\\Microsoft\\Avalon.Graphics\\%s", displayName);
|
|
|
|
// subkey for gamma, pixel structure
|
|
subrv = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
|
|
subkeyName, 0, KEY_QUERY_VALUE, &subKey);
|
|
|
|
if (subrv == ERROR_SUCCESS) {
|
|
size = sizeof(value);
|
|
subrv = RegQueryValueExW(subKey, L"GammaLevel", nullptr, &type,
|
|
(LPBYTE)&value, &size);
|
|
if (subrv == ERROR_SUCCESS && type == REG_DWORD) {
|
|
foundData = true;
|
|
ctinfo.gamma = value;
|
|
}
|
|
|
|
size = sizeof(value);
|
|
subrv = RegQueryValueExW(subKey, L"PixelStructure", nullptr, &type,
|
|
(LPBYTE)&value, &size);
|
|
if (subrv == ERROR_SUCCESS && type == REG_DWORD) {
|
|
foundData = true;
|
|
ctinfo.pixelStructure = value;
|
|
}
|
|
|
|
RegCloseKey(subKey);
|
|
}
|
|
|
|
// subkey for cleartype level, enhanced contrast
|
|
subrv = RegOpenKeyExW(HKEY_CURRENT_USER,
|
|
subkeyName, 0, KEY_QUERY_VALUE, &subKey);
|
|
|
|
if (subrv == ERROR_SUCCESS) {
|
|
size = sizeof(value);
|
|
subrv = RegQueryValueExW(subKey, L"ClearTypeLevel", nullptr, &type,
|
|
(LPBYTE)&value, &size);
|
|
if (subrv == ERROR_SUCCESS && type == REG_DWORD) {
|
|
foundData = true;
|
|
ctinfo.clearTypeLevel = value;
|
|
}
|
|
|
|
size = sizeof(value);
|
|
subrv = RegQueryValueExW(subKey, L"EnhancedContrastLevel",
|
|
nullptr, &type, (LPBYTE)&value, &size);
|
|
if (subrv == ERROR_SUCCESS && type == REG_DWORD) {
|
|
foundData = true;
|
|
ctinfo.enhancedContrast = value;
|
|
}
|
|
|
|
RegCloseKey(subKey);
|
|
}
|
|
|
|
if (foundData) {
|
|
aParams.AppendElement(ctinfo);
|
|
}
|
|
}
|
|
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
void
|
|
gfxWindowsPlatform::FontsPrefsChanged(const char *aPref)
|
|
{
|
|
bool clearTextFontCaches = true;
|
|
|
|
gfxPlatform::FontsPrefsChanged(aPref);
|
|
|
|
if (!aPref) {
|
|
mUseClearTypeForDownloadableFonts = UNINITIALIZED_VALUE;
|
|
mUseClearTypeAlways = UNINITIALIZED_VALUE;
|
|
} else if (!strcmp(GFX_DOWNLOADABLE_FONTS_USE_CLEARTYPE, aPref)) {
|
|
mUseClearTypeForDownloadableFonts = UNINITIALIZED_VALUE;
|
|
} else if (!strcmp(GFX_USE_CLEARTYPE_ALWAYS, aPref)) {
|
|
mUseClearTypeAlways = UNINITIALIZED_VALUE;
|
|
} else if (!strncmp(GFX_CLEARTYPE_PARAMS, aPref, strlen(GFX_CLEARTYPE_PARAMS))) {
|
|
SetupClearTypeParams();
|
|
} else {
|
|
clearTextFontCaches = false;
|
|
}
|
|
|
|
if (clearTextFontCaches) {
|
|
gfxFontCache *fc = gfxFontCache::GetCache();
|
|
if (fc) {
|
|
fc->Flush();
|
|
}
|
|
}
|
|
}
|
|
|
|
#define DISPLAY1_REGISTRY_KEY \
|
|
HKEY_CURRENT_USER, L"Software\\Microsoft\\Avalon.Graphics\\DISPLAY1"
|
|
|
|
#define ENHANCED_CONTRAST_VALUE_NAME L"EnhancedContrastLevel"
|
|
|
|
void
|
|
gfxWindowsPlatform::SetupClearTypeParams()
|
|
{
|
|
if (GetDWriteFactory()) {
|
|
// any missing prefs will default to invalid (-1) and be ignored;
|
|
// out-of-range values will also be ignored
|
|
FLOAT gamma = -1.0;
|
|
FLOAT contrast = -1.0;
|
|
FLOAT level = -1.0;
|
|
int geometry = -1;
|
|
int mode = -1;
|
|
int32_t value;
|
|
if (NS_SUCCEEDED(Preferences::GetInt(GFX_CLEARTYPE_PARAMS_GAMMA, &value))) {
|
|
if (value >= 1000 && value <= 2200) {
|
|
gamma = FLOAT(value / 1000.0);
|
|
}
|
|
}
|
|
|
|
if (NS_SUCCEEDED(Preferences::GetInt(GFX_CLEARTYPE_PARAMS_CONTRAST, &value))) {
|
|
if (value >= 0 && value <= 1000) {
|
|
contrast = FLOAT(value / 100.0);
|
|
}
|
|
}
|
|
|
|
if (NS_SUCCEEDED(Preferences::GetInt(GFX_CLEARTYPE_PARAMS_LEVEL, &value))) {
|
|
if (value >= 0 && value <= 100) {
|
|
level = FLOAT(value / 100.0);
|
|
}
|
|
}
|
|
|
|
if (NS_SUCCEEDED(Preferences::GetInt(GFX_CLEARTYPE_PARAMS_STRUCTURE, &value))) {
|
|
if (value >= 0 && value <= 2) {
|
|
geometry = value;
|
|
}
|
|
}
|
|
|
|
if (NS_SUCCEEDED(Preferences::GetInt(GFX_CLEARTYPE_PARAMS_MODE, &value))) {
|
|
if (value >= 0 && value <= 5) {
|
|
mode = value;
|
|
}
|
|
}
|
|
|
|
cairo_dwrite_set_cleartype_params(gamma, contrast, level, geometry, mode);
|
|
|
|
switch (mode) {
|
|
case DWRITE_RENDERING_MODE_ALIASED:
|
|
case DWRITE_RENDERING_MODE_CLEARTYPE_GDI_CLASSIC:
|
|
mMeasuringMode = DWRITE_MEASURING_MODE_GDI_CLASSIC;
|
|
break;
|
|
case DWRITE_RENDERING_MODE_CLEARTYPE_GDI_NATURAL:
|
|
mMeasuringMode = DWRITE_MEASURING_MODE_GDI_NATURAL;
|
|
break;
|
|
default:
|
|
mMeasuringMode = DWRITE_MEASURING_MODE_NATURAL;
|
|
break;
|
|
}
|
|
|
|
RefPtr<IDWriteRenderingParams> defaultRenderingParams;
|
|
GetDWriteFactory()->CreateRenderingParams(getter_AddRefs(defaultRenderingParams));
|
|
// For EnhancedContrast, we override the default if the user has not set it
|
|
// in the registry (by using the ClearType Tuner).
|
|
if (contrast < 0.0 || contrast > 10.0) {
|
|
HKEY hKey;
|
|
LONG res = RegOpenKeyExW(DISPLAY1_REGISTRY_KEY,
|
|
0, KEY_READ, &hKey);
|
|
if (res == ERROR_SUCCESS) {
|
|
res = RegQueryValueExW(hKey, ENHANCED_CONTRAST_VALUE_NAME,
|
|
nullptr, nullptr, nullptr, nullptr);
|
|
if (res == ERROR_SUCCESS) {
|
|
contrast = defaultRenderingParams->GetEnhancedContrast();
|
|
}
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
if (contrast < 0.0 || contrast > 10.0) {
|
|
contrast = 1.0;
|
|
}
|
|
}
|
|
|
|
if (GetDefaultContentBackend() == BackendType::SKIA) {
|
|
// Skia doesn't support a contrast value outside of 0-1, so default to 1.0
|
|
if (contrast < 0.0 || contrast > 1.0) {
|
|
NS_WARNING("Custom dwrite contrast not supported in Skia. Defaulting to 1.0.");
|
|
contrast = 1.0;
|
|
}
|
|
}
|
|
|
|
// For parameters that have not been explicitly set,
|
|
// we copy values from default params (or our overridden value for contrast)
|
|
if (gamma < 1.0 || gamma > 2.2) {
|
|
gamma = defaultRenderingParams->GetGamma();
|
|
}
|
|
|
|
if (level < 0.0 || level > 1.0) {
|
|
level = defaultRenderingParams->GetClearTypeLevel();
|
|
}
|
|
|
|
DWRITE_PIXEL_GEOMETRY dwriteGeometry =
|
|
static_cast<DWRITE_PIXEL_GEOMETRY>(geometry);
|
|
DWRITE_RENDERING_MODE renderMode =
|
|
static_cast<DWRITE_RENDERING_MODE>(mode);
|
|
|
|
if (dwriteGeometry < DWRITE_PIXEL_GEOMETRY_FLAT ||
|
|
dwriteGeometry > DWRITE_PIXEL_GEOMETRY_BGR) {
|
|
dwriteGeometry = defaultRenderingParams->GetPixelGeometry();
|
|
}
|
|
|
|
if (renderMode < DWRITE_RENDERING_MODE_DEFAULT ||
|
|
renderMode > DWRITE_RENDERING_MODE_CLEARTYPE_NATURAL_SYMMETRIC) {
|
|
renderMode = defaultRenderingParams->GetRenderingMode();
|
|
}
|
|
|
|
mRenderingParams[TEXT_RENDERING_NO_CLEARTYPE] = defaultRenderingParams;
|
|
|
|
HRESULT hr = GetDWriteFactory()->CreateCustomRenderingParams(
|
|
gamma, contrast, level, dwriteGeometry, renderMode,
|
|
getter_AddRefs(mRenderingParams[TEXT_RENDERING_NORMAL]));
|
|
if (FAILED(hr) || !mRenderingParams[TEXT_RENDERING_NORMAL]) {
|
|
mRenderingParams[TEXT_RENDERING_NORMAL] = defaultRenderingParams;
|
|
}
|
|
|
|
hr = GetDWriteFactory()->CreateCustomRenderingParams(
|
|
gamma, contrast, level,
|
|
dwriteGeometry, DWRITE_RENDERING_MODE_CLEARTYPE_GDI_CLASSIC,
|
|
getter_AddRefs(mRenderingParams[TEXT_RENDERING_GDI_CLASSIC]));
|
|
if (FAILED(hr) || !mRenderingParams[TEXT_RENDERING_GDI_CLASSIC]) {
|
|
mRenderingParams[TEXT_RENDERING_GDI_CLASSIC] =
|
|
defaultRenderingParams;
|
|
}
|
|
}
|
|
}
|
|
|
|
ReadbackManagerD3D11*
|
|
gfxWindowsPlatform::GetReadbackManager()
|
|
{
|
|
if (!mD3D11ReadbackManager) {
|
|
mD3D11ReadbackManager = new ReadbackManagerD3D11();
|
|
}
|
|
|
|
return mD3D11ReadbackManager;
|
|
}
|
|
|
|
bool
|
|
gfxWindowsPlatform::IsOptimus()
|
|
{
|
|
static int knowIsOptimus = -1;
|
|
if (knowIsOptimus == -1) {
|
|
// other potential optimus -- nvd3d9wrapx.dll & nvdxgiwrap.dll
|
|
if (GetModuleHandleA("nvumdshim.dll") ||
|
|
GetModuleHandleA("nvumdshimx.dll"))
|
|
{
|
|
knowIsOptimus = 1;
|
|
} else {
|
|
knowIsOptimus = 0;
|
|
}
|
|
}
|
|
return knowIsOptimus;
|
|
}
|
|
|
|
static inline bool
|
|
IsWARPStable()
|
|
{
|
|
// It seems like nvdxgiwrap makes a mess of WARP. See bug 1154703.
|
|
if (!IsWin8OrLater() || GetModuleHandleA("nvdxgiwrap.dll")) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static void
|
|
InitializeANGLEConfig()
|
|
{
|
|
FeatureState& d3d11ANGLE = gfxConfig::GetFeature(Feature::D3D11_HW_ANGLE);
|
|
|
|
if (!gfxConfig::IsEnabled(Feature::D3D11_COMPOSITING)) {
|
|
d3d11ANGLE.DisableByDefault(FeatureStatus::Unavailable, "D3D11 compositing is disabled",
|
|
NS_LITERAL_CSTRING("FEATURE_FAILURE_D3D11_DISABLED"));
|
|
return;
|
|
}
|
|
|
|
d3d11ANGLE.EnableByDefault();
|
|
|
|
nsCString message;
|
|
nsCString failureId;
|
|
if (!gfxPlatform::IsGfxInfoStatusOkay(nsIGfxInfo::FEATURE_DIRECT3D_11_ANGLE, &message,
|
|
failureId)) {
|
|
d3d11ANGLE.Disable(FeatureStatus::Blacklisted, message.get(), failureId);
|
|
}
|
|
|
|
}
|
|
|
|
void
|
|
gfxWindowsPlatform::InitializeDirectDrawConfig()
|
|
{
|
|
MOZ_ASSERT(XRE_IsParentProcess());
|
|
|
|
FeatureState& ddraw = gfxConfig::GetFeature(Feature::DIRECT_DRAW);
|
|
ddraw.EnableByDefault();
|
|
}
|
|
|
|
void
|
|
gfxWindowsPlatform::InitializeConfig()
|
|
{
|
|
if (XRE_IsParentProcess()) {
|
|
// The parent process first determines which features can be attempted.
|
|
// This information is relayed to content processes and the GPU process.
|
|
InitializeD3D9Config();
|
|
InitializeD3D11Config();
|
|
InitializeANGLEConfig();
|
|
InitializeD2DConfig();
|
|
} else {
|
|
FetchAndImportContentDeviceData();
|
|
InitializeANGLEConfig();
|
|
}
|
|
}
|
|
|
|
void
|
|
gfxWindowsPlatform::InitializeD3D9Config()
|
|
{
|
|
MOZ_ASSERT(XRE_IsParentProcess());
|
|
|
|
FeatureState& d3d9 = gfxConfig::GetFeature(Feature::D3D9_COMPOSITING);
|
|
|
|
if (!gfxConfig::IsEnabled(Feature::HW_COMPOSITING)) {
|
|
d3d9.DisableByDefault(FeatureStatus::Unavailable, "Hardware compositing is disabled",
|
|
NS_LITERAL_CSTRING("FEATURE_FAILURE_D3D9_NEED_HWCOMP"));
|
|
return;
|
|
}
|
|
|
|
if (!IsVistaOrLater()) {
|
|
d3d9.EnableByDefault();
|
|
} else {
|
|
d3d9.SetDefaultFromPref(
|
|
gfxPrefs::GetLayersAllowD3D9FallbackPrefName(),
|
|
true,
|
|
gfxPrefs::GetLayersAllowD3D9FallbackPrefDefault());
|
|
|
|
if (!d3d9.IsEnabled() && gfxPrefs::LayersPreferD3D9()) {
|
|
d3d9.UserEnable("Direct3D9 enabled via layers.prefer-d3d9");
|
|
}
|
|
}
|
|
|
|
nsCString message;
|
|
nsCString failureId;
|
|
if (!gfxPlatform::IsGfxInfoStatusOkay(nsIGfxInfo::FEATURE_DIRECT3D_9_LAYERS, &message,
|
|
failureId)) {
|
|
d3d9.Disable(FeatureStatus::Blacklisted, message.get(), failureId);
|
|
}
|
|
|
|
if (gfxConfig::IsForcedOnByUser(Feature::HW_COMPOSITING)) {
|
|
d3d9.UserForceEnable("Hardware compositing is force-enabled");
|
|
}
|
|
}
|
|
|
|
void
|
|
gfxWindowsPlatform::InitializeD3D11Config()
|
|
{
|
|
MOZ_ASSERT(XRE_IsParentProcess());
|
|
|
|
FeatureState& d3d11 = gfxConfig::GetFeature(Feature::D3D11_COMPOSITING);
|
|
|
|
if (!gfxConfig::IsEnabled(Feature::HW_COMPOSITING)) {
|
|
d3d11.DisableByDefault(FeatureStatus::Unavailable, "Hardware compositing is disabled",
|
|
NS_LITERAL_CSTRING("FEATURE_FAILURE_D3D11_NEED_HWCOMP"));
|
|
return;
|
|
}
|
|
|
|
d3d11.EnableByDefault();
|
|
|
|
if (!IsWin8OrLater() &&
|
|
!DeviceManagerDx::Get()->CheckRemotePresentSupport()) {
|
|
nsCOMPtr<nsIGfxInfo> gfxInfo;
|
|
gfxInfo = services::GetGfxInfo();
|
|
nsAutoString adaptorId;
|
|
gfxInfo->GetAdapterDeviceID(adaptorId);
|
|
// Blacklist Intel HD Graphics 510/520/530 on Windows 7 without platform
|
|
// update due to the crashes in Bug 1351349.
|
|
if (adaptorId.EqualsLiteral("0x1912") || adaptorId.EqualsLiteral("0x1916") ||
|
|
adaptorId.EqualsLiteral("0x1902")) {
|
|
d3d11.Disable(FeatureStatus::Blacklisted, "Blacklisted, see bug 1351349",
|
|
NS_LITERAL_CSTRING("FEATURE_FAILURE_BUG_1351349"));
|
|
}
|
|
}
|
|
|
|
// If the user prefers D3D9, act as though they disabled D3D11.
|
|
if (gfxPrefs::LayersPreferD3D9()) {
|
|
d3d11.UserDisable("Disabled due to user preference for Direct3D 9",
|
|
NS_LITERAL_CSTRING("FEATURE_FAILURE_D3D11_PREF"));
|
|
return;
|
|
}
|
|
|
|
nsCString message;
|
|
nsCString failureId;
|
|
if (!gfxPlatform::IsGfxInfoStatusOkay(nsIGfxInfo::FEATURE_DIRECT3D_11_LAYERS, &message, failureId)) {
|
|
d3d11.Disable(FeatureStatus::Blacklisted, message.get(), failureId);
|
|
}
|
|
|
|
// Check if the user really, really wants WARP.
|
|
if (gfxPrefs::LayersD3D11ForceWARP()) {
|
|
// Force D3D11 on even if we disabled it.
|
|
d3d11.UserForceEnable("User force-enabled WARP");
|
|
}
|
|
}
|
|
|
|
void
|
|
gfxWindowsPlatform::InitializeDevices()
|
|
{
|
|
MOZ_ASSERT(!InSafeMode());
|
|
|
|
if (XRE_IsParentProcess()) {
|
|
// If we're the UI process, and the GPU process is enabled, then we don't
|
|
// initialize any DirectX devices. We do leave them enabled in gfxConfig
|
|
// though. If the GPU process fails to create these devices it will send
|
|
// a message back and we'll update their status.
|
|
if (InitGPUProcessSupport()) {
|
|
return;
|
|
}
|
|
|
|
// No GPU process, continue initializing devices as normal.
|
|
}
|
|
|
|
// If acceleration is disabled, we refuse to initialize anything.
|
|
if (!gfxConfig::IsEnabled(Feature::HW_COMPOSITING)) {
|
|
return;
|
|
}
|
|
|
|
// If we previously crashed initializing devices, bail out now.
|
|
D3D11LayersCrashGuard detectCrashes;
|
|
if (detectCrashes.Crashed()) {
|
|
gfxConfig::SetFailed(Feature::HW_COMPOSITING,
|
|
FeatureStatus::CrashedOnStartup,
|
|
"Crashed during startup in a previous session");
|
|
gfxConfig::SetFailed(Feature::D3D11_COMPOSITING,
|
|
FeatureStatus::CrashedOnStartup,
|
|
"Harware acceleration crashed during startup in a previous session");
|
|
gfxConfig::SetFailed(Feature::DIRECT2D,
|
|
FeatureStatus::CrashedOnStartup,
|
|
"Harware acceleration crashed during startup in a previous session");
|
|
return;
|
|
}
|
|
|
|
// First, initialize D3D11. If this succeeds we attempt to use Direct2D.
|
|
InitializeD3D11();
|
|
InitializeD2D();
|
|
}
|
|
|
|
void
|
|
gfxWindowsPlatform::InitializeD3D11()
|
|
{
|
|
// This function attempts to initialize our D3D11 devices, if the hardware
|
|
// is not blacklisted for D3D11 layers. This first attempt will try to create
|
|
// a hardware accelerated device. If this creation fails or the hardware is
|
|
// blacklisted, then this function will abort if WARP is disabled, causing us
|
|
// to fallback to D3D9 or Basic layers. If WARP is not disabled it will use
|
|
// a WARP device which should always be available on Windows 7 and higher.
|
|
if (!gfxConfig::IsEnabled(Feature::D3D11_COMPOSITING)) {
|
|
return;
|
|
}
|
|
|
|
DeviceManagerDx* dm = DeviceManagerDx::Get();
|
|
if (XRE_IsParentProcess()) {
|
|
if (!dm->CreateCompositorDevices()) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
dm->CreateContentDevices();
|
|
|
|
// Content process failed to create the d3d11 device while parent process
|
|
// succeed.
|
|
if (XRE_IsContentProcess() &&
|
|
!gfxConfig::IsEnabled(Feature::D3D11_COMPOSITING)) {
|
|
gfxCriticalError() << "[D3D11] Failed to create the D3D11 device in content \
|
|
process.";
|
|
}
|
|
}
|
|
|
|
void
|
|
gfxWindowsPlatform::InitializeD2DConfig()
|
|
{
|
|
FeatureState& d2d1 = gfxConfig::GetFeature(Feature::DIRECT2D);
|
|
|
|
if (!gfxConfig::IsEnabled(Feature::D3D11_COMPOSITING)) {
|
|
d2d1.DisableByDefault(FeatureStatus::Unavailable, "Direct2D requires Direct3D 11 compositing",
|
|
NS_LITERAL_CSTRING("FEATURE_FAILURE_D2D_D3D11_COMP"));
|
|
return;
|
|
}
|
|
if (!IsVistaOrLater()) {
|
|
d2d1.DisableByDefault(FeatureStatus::Unavailable, "Direct2D is not available on Windows XP",
|
|
NS_LITERAL_CSTRING("FEATURE_FAILURE_D2D_XP"));
|
|
return;
|
|
}
|
|
|
|
d2d1.SetDefaultFromPref(
|
|
gfxPrefs::GetDirect2DDisabledPrefName(),
|
|
false,
|
|
gfxPrefs::GetDirect2DDisabledPrefDefault());
|
|
|
|
nsCString message;
|
|
nsCString failureId;
|
|
if (!gfxPlatform::IsGfxInfoStatusOkay(nsIGfxInfo::FEATURE_DIRECT2D, &message, failureId)) {
|
|
d2d1.Disable(FeatureStatus::Blacklisted, message.get(), failureId);
|
|
}
|
|
|
|
if (!d2d1.IsEnabled() && gfxPrefs::Direct2DForceEnabled()) {
|
|
d2d1.UserForceEnable("Force-enabled via user-preference");
|
|
}
|
|
}
|
|
|
|
void
|
|
gfxWindowsPlatform::InitializeD2D()
|
|
{
|
|
FeatureState& d2d1 = gfxConfig::GetFeature(Feature::DIRECT2D);
|
|
|
|
DeviceManagerDx* dm = DeviceManagerDx::Get();
|
|
|
|
// We don't know this value ahead of time, but the user can force-override
|
|
// it, so we use Disable instead of SetFailed.
|
|
if (dm->IsWARP()) {
|
|
d2d1.Disable(FeatureStatus::Blocked, "Direct2D is not compatible with Direct3D11 WARP",
|
|
NS_LITERAL_CSTRING("FEATURE_FAILURE_D2D_WARP_BLOCK"));
|
|
}
|
|
|
|
// If we pass all the initial checks, we can proceed to runtime decisions.
|
|
if (!d2d1.IsEnabled()) {
|
|
return;
|
|
}
|
|
|
|
if (!Factory::SupportsD2D1()) {
|
|
d2d1.SetFailed(FeatureStatus::Unavailable, "Failed to acquire a Direct2D 1.1 factory",
|
|
NS_LITERAL_CSTRING("FEATURE_FAILURE_D2D_FACTORY"));
|
|
return;
|
|
}
|
|
|
|
if (!dm->GetContentDevice()) {
|
|
d2d1.SetFailed(FeatureStatus::Failed, "Failed to acquire a Direct3D 11 content device",
|
|
NS_LITERAL_CSTRING("FEATURE_FAILURE_D2D_DEVICE"));
|
|
return;
|
|
}
|
|
|
|
if (!dm->TextureSharingWorks()) {
|
|
d2d1.SetFailed(FeatureStatus::Failed, "Direct3D11 device does not support texture sharing",
|
|
NS_LITERAL_CSTRING("FEATURE_FAILURE_D2D_TXT_SHARING"));
|
|
return;
|
|
}
|
|
|
|
// Using Direct2D depends on DWrite support.
|
|
if (!mDWriteFactory && !InitDWriteSupport()) {
|
|
d2d1.SetFailed(FeatureStatus::Failed, "Failed to initialize DirectWrite support",
|
|
NS_LITERAL_CSTRING("FEATURE_FAILURE_D2D_DWRITE"));
|
|
return;
|
|
}
|
|
|
|
// Verify that Direct2D device creation succeeded.
|
|
RefPtr<ID3D11Device> contentDevice = dm->GetContentDevice();
|
|
if (!Factory::SetDirect3D11Device(contentDevice)) {
|
|
d2d1.SetFailed(FeatureStatus::Failed, "Failed to create a Direct2D device",
|
|
NS_LITERAL_CSTRING("FEATURE_FAILURE_D2D_CREATE_FAILED"));
|
|
return;
|
|
}
|
|
|
|
MOZ_ASSERT(d2d1.IsEnabled());
|
|
}
|
|
|
|
bool
|
|
gfxWindowsPlatform::InitGPUProcessSupport()
|
|
{
|
|
FeatureState& gpuProc = gfxConfig::GetFeature(Feature::GPU_PROCESS);
|
|
|
|
if (!gpuProc.IsEnabled()) {
|
|
return false;
|
|
}
|
|
|
|
if (!gfxConfig::IsEnabled(Feature::D3D11_COMPOSITING)) {
|
|
// Don't use the GPU process if not using D3D11.
|
|
gpuProc.Disable(
|
|
FeatureStatus::Unavailable,
|
|
"Not using GPU Process since D3D11 is unavailable",
|
|
NS_LITERAL_CSTRING("FEATURE_FAILURE_NO_D3D11"));
|
|
} else if (!IsWin7SP1OrLater()) {
|
|
// For Windows XP, we simply don't care enough to support this
|
|
// configuration. On Windows Vista and 7 Pre-SP1, DXGI 1.2 is not
|
|
// available and remote presentation for D3D11 will not work. Rather
|
|
// than take a regression and use D3D9, we revert back to in-process
|
|
// rendering.
|
|
gpuProc.Disable(
|
|
FeatureStatus::Unavailable,
|
|
"Windows XP, Vista, and 7 Pre-SP1 cannot use the GPU process",
|
|
NS_LITERAL_CSTRING("FEATURE_FAILURE_OLD_WINDOWS"));
|
|
} else if (!IsWin8OrLater()) {
|
|
// Windows 7 SP1 can have DXGI 1.2 only via the Platform Update, so we
|
|
// explicitly check for that here.
|
|
if (!DeviceManagerDx::Get()->CheckRemotePresentSupport()) {
|
|
gpuProc.Disable(
|
|
FeatureStatus::Unavailable,
|
|
"GPU Process requires the Windows 7 Platform Update",
|
|
NS_LITERAL_CSTRING("FEATURE_FAILURE_PLATFORM_UPDATE"));
|
|
} else {
|
|
// Clear anything cached by the above call since we don't need it.
|
|
DeviceManagerDx::Get()->ResetDevices();
|
|
}
|
|
}
|
|
|
|
// If we're still enabled at this point, the user set the force-enabled pref.
|
|
return gpuProc.IsEnabled();
|
|
}
|
|
|
|
bool
|
|
gfxWindowsPlatform::DwmCompositionEnabled()
|
|
{
|
|
if (!IsVistaOrLater()) {
|
|
return false;
|
|
}
|
|
|
|
MOZ_ASSERT(WinUtils::dwmIsCompositionEnabledPtr);
|
|
BOOL dwmEnabled = false;
|
|
|
|
if (FAILED(WinUtils::dwmIsCompositionEnabledPtr(&dwmEnabled))) {
|
|
return false;
|
|
}
|
|
|
|
return dwmEnabled;
|
|
}
|
|
|
|
class D3DVsyncSource final : public VsyncSource
|
|
{
|
|
public:
|
|
|
|
class D3DVsyncDisplay final : public VsyncSource::Display
|
|
{
|
|
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(D3DVsyncDisplay)
|
|
public:
|
|
D3DVsyncDisplay()
|
|
: mPrevVsync(TimeStamp::Now())
|
|
, mVsyncEnabledLock("D3DVsyncEnabledLock")
|
|
, mVsyncEnabled(false)
|
|
{
|
|
mVsyncThread = new base::Thread("WindowsVsyncThread");
|
|
MOZ_RELEASE_ASSERT(mVsyncThread->Start(), "GFX: Could not start Windows vsync thread");
|
|
SetVsyncRate();
|
|
}
|
|
|
|
void SetVsyncRate()
|
|
{
|
|
if (!gfxWindowsPlatform::GetPlatform()->DwmCompositionEnabled()) {
|
|
mVsyncRate = TimeDuration::FromMilliseconds(1000.0 / 60.0);
|
|
return;
|
|
}
|
|
|
|
DWM_TIMING_INFO vblankTime;
|
|
// Make sure to init the cbSize, otherwise GetCompositionTiming will fail
|
|
vblankTime.cbSize = sizeof(DWM_TIMING_INFO);
|
|
HRESULT hr = WinUtils::dwmGetCompositionTimingInfoPtr(0, &vblankTime);
|
|
if (SUCCEEDED(hr)) {
|
|
UNSIGNED_RATIO refreshRate = vblankTime.rateRefresh;
|
|
// We get the rate in hertz / time, but we want the rate in ms.
|
|
float rate = ((float) refreshRate.uiDenominator
|
|
/ (float) refreshRate.uiNumerator) * 1000;
|
|
mVsyncRate = TimeDuration::FromMilliseconds(rate);
|
|
} else {
|
|
mVsyncRate = TimeDuration::FromMilliseconds(1000.0 / 60.0);
|
|
}
|
|
}
|
|
|
|
virtual void Shutdown() override
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
DisableVsync();
|
|
mVsyncThread->Stop();
|
|
delete mVsyncThread;
|
|
}
|
|
|
|
virtual void EnableVsync() override
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_ASSERT(mVsyncThread->IsRunning());
|
|
{ // scope lock
|
|
MonitorAutoLock lock(mVsyncEnabledLock);
|
|
if (mVsyncEnabled) {
|
|
return;
|
|
}
|
|
mVsyncEnabled = true;
|
|
}
|
|
|
|
mVsyncThread->message_loop()->PostTask(
|
|
NewRunnableMethod(this, &D3DVsyncDisplay::VBlankLoop));
|
|
}
|
|
|
|
virtual void DisableVsync() override
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_ASSERT(mVsyncThread->IsRunning());
|
|
MonitorAutoLock lock(mVsyncEnabledLock);
|
|
if (!mVsyncEnabled) {
|
|
return;
|
|
}
|
|
mVsyncEnabled = false;
|
|
}
|
|
|
|
virtual bool IsVsyncEnabled() override
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MonitorAutoLock lock(mVsyncEnabledLock);
|
|
return mVsyncEnabled;
|
|
}
|
|
|
|
virtual TimeDuration GetVsyncRate() override
|
|
{
|
|
return mVsyncRate;
|
|
}
|
|
|
|
void ScheduleSoftwareVsync(TimeStamp aVsyncTimestamp)
|
|
{
|
|
MOZ_ASSERT(IsInVsyncThread());
|
|
NS_WARNING("DwmComposition dynamically disabled, falling back to software timers");
|
|
|
|
TimeStamp nextVsync = aVsyncTimestamp + mVsyncRate;
|
|
TimeDuration delay = nextVsync - TimeStamp::Now();
|
|
if (delay.ToMilliseconds() < 0) {
|
|
delay = mozilla::TimeDuration::FromMilliseconds(0);
|
|
}
|
|
|
|
mVsyncThread->message_loop()->PostDelayedTask(
|
|
NewRunnableMethod(this, &D3DVsyncDisplay::VBlankLoop),
|
|
delay.ToMilliseconds());
|
|
}
|
|
|
|
// Returns the timestamp for the just happened vsync
|
|
TimeStamp GetVBlankTime()
|
|
{
|
|
TimeStamp vsync = TimeStamp::Now();
|
|
TimeStamp now = vsync;
|
|
|
|
DWM_TIMING_INFO vblankTime;
|
|
// Make sure to init the cbSize, otherwise
|
|
// GetCompositionTiming will fail
|
|
vblankTime.cbSize = sizeof(DWM_TIMING_INFO);
|
|
HRESULT hr = WinUtils::dwmGetCompositionTimingInfoPtr(0, &vblankTime);
|
|
if (!SUCCEEDED(hr)) {
|
|
return vsync;
|
|
}
|
|
|
|
LARGE_INTEGER frequency;
|
|
QueryPerformanceFrequency(&frequency);
|
|
|
|
LARGE_INTEGER qpcNow;
|
|
QueryPerformanceCounter(&qpcNow);
|
|
|
|
const int microseconds = 1000000;
|
|
int64_t adjust = qpcNow.QuadPart - vblankTime.qpcVBlank;
|
|
int64_t usAdjust = (adjust * microseconds) / frequency.QuadPart;
|
|
vsync -= TimeDuration::FromMicroseconds((double) usAdjust);
|
|
|
|
if (IsWin10OrLater()) {
|
|
// On Windows 10 and on, DWMGetCompositionTimingInfo, mostly
|
|
// reports the upcoming vsync time, which is in the future.
|
|
// It can also sometimes report a vblank time in the past.
|
|
// Since large parts of Gecko assume TimeStamps can't be in future,
|
|
// use the previous vsync.
|
|
|
|
// Windows 10 and Intel HD vsync timestamps are messy and
|
|
// all over the place once in a while. Most of the time,
|
|
// it reports the upcoming vsync. Sometimes, that upcoming
|
|
// vsync is in the past. Sometimes that upcoming vsync is before
|
|
// the previously seen vsync.
|
|
// In these error cases, normalize to Now();
|
|
if (vsync >= now) {
|
|
vsync = vsync - mVsyncRate;
|
|
}
|
|
}
|
|
|
|
// On Windows 7 and 8, DwmFlush wakes up AFTER qpcVBlankTime
|
|
// from DWMGetCompositionTimingInfo. We can return the adjusted vsync.
|
|
if (vsync >= now) {
|
|
vsync = now;
|
|
}
|
|
|
|
// Our vsync time is some time very far in the past, adjust to Now.
|
|
// 4 ms is arbitrary, so feel free to pick something else if this isn't
|
|
// working. See the comment above within IsWin10OrLater().
|
|
if ((now - vsync).ToMilliseconds() > 4.0) {
|
|
vsync = now;
|
|
}
|
|
|
|
return vsync;
|
|
}
|
|
|
|
void VBlankLoop()
|
|
{
|
|
MOZ_ASSERT(IsInVsyncThread());
|
|
MOZ_ASSERT(sizeof(int64_t) == sizeof(QPC_TIME));
|
|
|
|
TimeStamp vsync = TimeStamp::Now();
|
|
mPrevVsync = TimeStamp();
|
|
TimeStamp flushTime = TimeStamp::Now();
|
|
TimeDuration longVBlank = mVsyncRate * 2;
|
|
|
|
for (;;) {
|
|
{ // scope lock
|
|
MonitorAutoLock lock(mVsyncEnabledLock);
|
|
if (!mVsyncEnabled) return;
|
|
}
|
|
|
|
// Large parts of gecko assume that the refresh driver timestamp
|
|
// must be <= Now() and cannot be in the future.
|
|
MOZ_ASSERT(vsync <= TimeStamp::Now());
|
|
Display::NotifyVsync(vsync);
|
|
|
|
// DwmComposition can be dynamically enabled/disabled
|
|
// so we have to check every time that it's available.
|
|
// When it is unavailable, we fallback to software but will try
|
|
// to get back to dwm rendering once it's re-enabled
|
|
if (!gfxWindowsPlatform::GetPlatform()->DwmCompositionEnabled()) {
|
|
ScheduleSoftwareVsync(vsync);
|
|
return;
|
|
}
|
|
|
|
// Using WaitForVBlank, the whole system dies because WaitForVBlank
|
|
// only works if it's run on the same thread as the Present();
|
|
HRESULT hr = WinUtils::dwmFlushProcPtr();
|
|
if (!SUCCEEDED(hr)) {
|
|
// DWMFlush isn't working, fallback to software vsync.
|
|
ScheduleSoftwareVsync(TimeStamp::Now());
|
|
return;
|
|
}
|
|
|
|
TimeStamp now = TimeStamp::Now();
|
|
TimeDuration flushDiff = now - flushTime;
|
|
flushTime = now;
|
|
if ((flushDiff > longVBlank) || mPrevVsync.IsNull()) {
|
|
// Our vblank took longer than 2 intervals, readjust our timestamps
|
|
vsync = GetVBlankTime();
|
|
mPrevVsync = vsync;
|
|
} else {
|
|
// Instead of giving the actual vsync time, a constant interval
|
|
// between vblanks instead of the noise generated via hardware
|
|
// is actually what we want. Most apps just care about the diff
|
|
// between vblanks to animate, so a clean constant interval is
|
|
// smoother.
|
|
vsync = mPrevVsync + mVsyncRate;
|
|
if (vsync > now) {
|
|
// DWMFlush woke up very early, so readjust our times again
|
|
vsync = GetVBlankTime();
|
|
}
|
|
|
|
if (vsync <= mPrevVsync) {
|
|
vsync = TimeStamp::Now();
|
|
}
|
|
|
|
if ((now - vsync).ToMilliseconds() > 2.0) {
|
|
// Account for time drift here where vsync never quite catches up to
|
|
// Now and we'd fall ever so slightly further behind Now().
|
|
vsync = GetVBlankTime();
|
|
}
|
|
|
|
mPrevVsync = vsync;
|
|
}
|
|
} // end for
|
|
}
|
|
|
|
private:
|
|
virtual ~D3DVsyncDisplay()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
}
|
|
|
|
bool IsInVsyncThread()
|
|
{
|
|
return mVsyncThread->thread_id() == PlatformThread::CurrentId();
|
|
}
|
|
|
|
TimeStamp mPrevVsync;
|
|
Monitor mVsyncEnabledLock;
|
|
base::Thread* mVsyncThread;
|
|
TimeDuration mVsyncRate;
|
|
bool mVsyncEnabled;
|
|
}; // end d3dvsyncdisplay
|
|
|
|
D3DVsyncSource()
|
|
{
|
|
mPrimaryDisplay = new D3DVsyncDisplay();
|
|
}
|
|
|
|
virtual Display& GetGlobalDisplay() override
|
|
{
|
|
return *mPrimaryDisplay;
|
|
}
|
|
|
|
private:
|
|
virtual ~D3DVsyncSource()
|
|
{
|
|
}
|
|
RefPtr<D3DVsyncDisplay> mPrimaryDisplay;
|
|
}; // end D3DVsyncSource
|
|
|
|
already_AddRefed<mozilla::gfx::VsyncSource>
|
|
gfxWindowsPlatform::CreateHardwareVsyncSource()
|
|
{
|
|
MOZ_RELEASE_ASSERT(NS_IsMainThread(), "GFX: Not in main thread.");
|
|
if (!WinUtils::dwmIsCompositionEnabledPtr) {
|
|
NS_WARNING("Dwm composition not available, falling back to software vsync");
|
|
return gfxPlatform::CreateHardwareVsyncSource();
|
|
}
|
|
|
|
BOOL dwmEnabled = false;
|
|
WinUtils::dwmIsCompositionEnabledPtr(&dwmEnabled);
|
|
if (!dwmEnabled) {
|
|
NS_WARNING("DWM not enabled, falling back to software vsync");
|
|
return gfxPlatform::CreateHardwareVsyncSource();
|
|
}
|
|
|
|
RefPtr<VsyncSource> d3dVsyncSource = new D3DVsyncSource();
|
|
return d3dVsyncSource.forget();
|
|
}
|
|
|
|
bool
|
|
gfxWindowsPlatform::SupportsApzTouchInput() const
|
|
{
|
|
int value = gfxPrefs::TouchEventsEnabled();
|
|
return value == 1 || value == 2;
|
|
}
|
|
|
|
void
|
|
gfxWindowsPlatform::GetAcceleratedCompositorBackends(nsTArray<LayersBackend>& aBackends)
|
|
{
|
|
if (gfxConfig::IsEnabled(Feature::OPENGL_COMPOSITING) && gfxPrefs::LayersPreferOpenGL()) {
|
|
aBackends.AppendElement(LayersBackend::LAYERS_OPENGL);
|
|
}
|
|
|
|
if (gfxConfig::IsEnabled(Feature::D3D9_COMPOSITING) && gfxPrefs::LayersPreferD3D9()) {
|
|
aBackends.AppendElement(LayersBackend::LAYERS_D3D9);
|
|
}
|
|
|
|
if (gfxConfig::IsEnabled(Feature::D3D11_COMPOSITING)) {
|
|
aBackends.AppendElement(LayersBackend::LAYERS_D3D11);
|
|
}
|
|
|
|
if (gfxConfig::IsEnabled(Feature::D3D9_COMPOSITING) && !gfxPrefs::LayersPreferD3D9()) {
|
|
aBackends.AppendElement(LayersBackend::LAYERS_D3D9);
|
|
}
|
|
}
|
|
|
|
void
|
|
gfxWindowsPlatform::ImportGPUDeviceData(const mozilla::gfx::GPUDeviceData& aData)
|
|
{
|
|
MOZ_ASSERT(XRE_IsParentProcess());
|
|
|
|
gfxPlatform::ImportGPUDeviceData(aData);
|
|
|
|
gfxConfig::ImportChange(Feature::D3D11_COMPOSITING, aData.d3d11Compositing());
|
|
gfxConfig::ImportChange(Feature::D3D9_COMPOSITING, aData.d3d9Compositing());
|
|
|
|
DeviceManagerDx* dm = DeviceManagerDx::Get();
|
|
if (gfxConfig::IsEnabled(Feature::D3D11_COMPOSITING)) {
|
|
dm->ImportDeviceInfo(aData.gpuDevice().get_D3D11DeviceStatus());
|
|
} else {
|
|
// There should be no devices, so this just takes away the device status.
|
|
dm->ResetDevices();
|
|
|
|
// Make sure we disable D2D if content processes might use it.
|
|
FeatureState& d2d1 = gfxConfig::GetFeature(Feature::DIRECT2D);
|
|
if (d2d1.IsEnabled()) {
|
|
d2d1.SetFailed(
|
|
FeatureStatus::Unavailable,
|
|
"Direct2D requires Direct3D 11 compositing",
|
|
NS_LITERAL_CSTRING("FEATURE_FAILURE_D2D_D3D11_COMP"));
|
|
}
|
|
}
|
|
|
|
// CanUseHardwareVideoDecoding depends on d3d11 state, so update
|
|
// the cached value now.
|
|
UpdateCanUseHardwareVideoDecoding();
|
|
|
|
// For completeness (and messaging in about:support). Content recomputes this
|
|
// on its own, and we won't use ANGLE in the UI process if we're using a GPU
|
|
// process.
|
|
UpdateANGLEConfig();
|
|
}
|
|
|
|
void
|
|
gfxWindowsPlatform::ImportContentDeviceData(const mozilla::gfx::ContentDeviceData& aData)
|
|
{
|
|
MOZ_ASSERT(XRE_IsContentProcess());
|
|
|
|
gfxPlatform::ImportContentDeviceData(aData);
|
|
|
|
const DevicePrefs& prefs = aData.prefs();
|
|
gfxConfig::Inherit(Feature::D3D11_COMPOSITING, prefs.d3d11Compositing());
|
|
gfxConfig::Inherit(Feature::D3D9_COMPOSITING, prefs.d3d9Compositing());
|
|
gfxConfig::Inherit(Feature::DIRECT2D, prefs.useD2D1());
|
|
|
|
if (gfxConfig::IsEnabled(Feature::D3D11_COMPOSITING)) {
|
|
DeviceManagerDx* dm = DeviceManagerDx::Get();
|
|
dm->ImportDeviceInfo(aData.d3d11());
|
|
}
|
|
}
|
|
|
|
void
|
|
gfxWindowsPlatform::BuildContentDeviceData(ContentDeviceData* aOut)
|
|
{
|
|
// Check for device resets before giving back new graphics information.
|
|
UpdateRenderMode();
|
|
|
|
gfxPlatform::BuildContentDeviceData(aOut);
|
|
|
|
const FeatureState& d3d11 = gfxConfig::GetFeature(Feature::D3D11_COMPOSITING);
|
|
aOut->prefs().d3d11Compositing() = d3d11.GetValue();
|
|
aOut->prefs().d3d9Compositing() = gfxConfig::GetValue(Feature::D3D9_COMPOSITING);
|
|
aOut->prefs().useD2D1() = gfxConfig::GetValue(Feature::DIRECT2D);
|
|
|
|
if (d3d11.IsEnabled()) {
|
|
DeviceManagerDx* dm = DeviceManagerDx::Get();
|
|
dm->ExportDeviceInfo(&aOut->d3d11());
|
|
}
|
|
}
|
|
|
|
bool
|
|
gfxWindowsPlatform::SupportsPluginDirectDXGIDrawing()
|
|
{
|
|
DeviceManagerDx* dm = DeviceManagerDx::Get();
|
|
if (!dm->GetContentDevice() || !dm->TextureSharingWorks()) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|