1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
|
/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* 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/. */
#ifndef GFX_WINDOWS_PLATFORM_H
#define GFX_WINDOWS_PLATFORM_H
#include "gfxCrashReporterUtils.h"
#include "gfxFontUtils.h"
#include "gfxWindowsSurface.h"
#include "gfxFont.h"
#include "gfxDWriteFonts.h"
#include "gfxPlatform.h"
#include "gfxTelemetry.h"
#include "gfxTypes.h"
#include "mozilla/Attributes.h"
#include "mozilla/Atomics.h"
#include "nsTArray.h"
#include "mozilla/Mutex.h"
#include "mozilla/RefPtr.h"
#include <windows.h>
#include <objbase.h>
#include <dxgi.h>
// This header is available in the June 2010 SDK and in the Win8 SDK
#include <d3dcommon.h>
// Win 8.0 SDK types we'll need when building using older sdks.
#if !defined(D3D_FEATURE_LEVEL_11_1) // defined in the 8.0 SDK only
# define D3D_FEATURE_LEVEL_11_1 static_cast<D3D_FEATURE_LEVEL>(0xb100)
# define D3D_FL9_1_REQ_TEXTURE2D_U_OR_V_DIMENSION 2048
# define D3D_FL9_3_REQ_TEXTURE2D_U_OR_V_DIMENSION 4096
#endif
namespace mozilla {
namespace gfx {
class DrawTarget;
class FeatureState;
class DeviceManagerDx;
} // namespace gfx
} // namespace mozilla
struct IDirect3DDevice9;
struct ID3D11Device;
struct IDXGIAdapter1;
/**
* Utility to get a Windows HDC from a Moz2D DrawTarget. If the DrawTarget is
* not backed by a HDC this will get the HDC for the screen device context
* instead.
*/
class MOZ_STACK_CLASS DCForMetrics final {
public:
explicit DCForMetrics();
~DCForMetrics() { ReleaseDC(nullptr, mDC); }
operator HDC() { return mDC; }
private:
HDC mDC;
};
// ClearType parameters set by running ClearType tuner
struct ClearTypeParameterInfo {
ClearTypeParameterInfo()
: gamma(-1),
pixelStructure(-1),
clearTypeLevel(-1),
enhancedContrast(-1) {}
nsString displayName; // typically just 'DISPLAY1'
int32_t gamma;
int32_t pixelStructure;
int32_t clearTypeLevel;
int32_t enhancedContrast;
};
class gfxWindowsPlatform final : public gfxPlatform {
friend class mozilla::gfx::DeviceManagerDx;
public:
enum TextRenderingMode {
TEXT_RENDERING_NO_CLEARTYPE,
TEXT_RENDERING_NORMAL,
TEXT_RENDERING_GDI_CLASSIC,
TEXT_RENDERING_COUNT
};
gfxWindowsPlatform();
virtual ~gfxWindowsPlatform();
static gfxWindowsPlatform* GetPlatform() {
return (gfxWindowsPlatform*)gfxPlatform::GetPlatform();
}
void EnsureDevicesInitialized() override;
bool DevicesInitialized() override;
bool CreatePlatformFontList() override;
virtual already_AddRefed<gfxASurface> CreateOffscreenSurface(
const IntSize& aSize, gfxImageFormat aFormat) override;
enum RenderMode {
/* Use GDI and windows surfaces */
RENDER_GDI = 0,
/* Use 32bpp image surfaces and call StretchDIBits */
RENDER_IMAGE_STRETCH32,
/* Use 32bpp image surfaces, and do 32->24 conversion before calling
StretchDIBits */
RENDER_IMAGE_STRETCH24,
/* Use Direct2D rendering */
RENDER_DIRECT2D,
/* max */
RENDER_MODE_MAX
};
bool IsDirect2DBackend();
/**
* Updates render mode with relation to the current preferences and
* available devices.
*/
void UpdateRenderMode();
/**
* Verifies a D2D device is present and working, will attempt to create one
* it is non-functional or non-existant.
*
* \param aAttemptForce Attempt to force D2D cairo device creation by using
* cairo device creation routines.
*/
void VerifyD2DDevice(bool aAttemptForce);
void GetCommonFallbackFonts(uint32_t aCh, Script aRunScript,
eFontPresentation aPresentation,
nsTArray<const char*>& aFontList) override;
bool CanUseHardwareVideoDecoding() override;
void CompositorUpdated() override;
bool DidRenderingDeviceReset(
DeviceResetReason* aResetReason = nullptr) override;
void SchedulePaintIfDeviceReset() override;
void CheckForContentOnlyDeviceReset();
mozilla::gfx::BackendType GetContentBackendFor(
mozilla::layers::LayersBackend aLayers) override;
mozilla::gfx::BackendType GetPreferredCanvasBackend() override;
static void GetDLLVersion(char16ptr_t aDLLPath, nsAString& aVersion);
// returns ClearType tuning information for each display
static void GetCleartypeParams(nsTArray<ClearTypeParameterInfo>& aParams);
void FontsPrefsChanged(const char* aPref) override;
static inline bool DWriteEnabled() {
return !!mozilla::gfx::Factory::GetDWriteFactory();
}
public:
static nsresult GetGpuTimeSinceProcessStartInMs(uint64_t* aResult);
static bool IsOptimus();
bool SupportsApzWheelInput() const override { return true; }
// Recreate devices as needed for a device reset. Returns true if a device
// reset occurred.
bool HandleDeviceReset();
void UpdateBackendPrefs();
already_AddRefed<mozilla::gfx::VsyncSource> CreateGlobalHardwareVsyncSource()
override;
static mozilla::Atomic<size_t> sD3D11SharedTextures;
static mozilla::Atomic<size_t> sD3D9SharedTextures;
bool SupportsPluginDirectBitmapDrawing() override { return true; }
static void RecordContentDeviceFailure(
mozilla::gfx::TelemetryDeviceCode aDevice);
static void InitMemoryReportersForGPUProcess();
static bool CheckVariationFontSupport();
protected:
bool AccelerateLayersByDefault() override { return true; }
nsTArray<uint8_t> GetPlatformCMSOutputProfileData() override;
public:
static nsTArray<uint8_t> GetPlatformCMSOutputProfileData_Impl();
protected:
void GetPlatformDisplayInfo(mozilla::widget::InfoObject& aObj) override;
void ImportGPUDeviceData(const mozilla::gfx::GPUDeviceData& aData) override;
void ImportContentDeviceData(
const mozilla::gfx::ContentDeviceData& aData) override;
void BuildContentDeviceData(mozilla::gfx::ContentDeviceData* aOut) override;
BackendPrefsData GetBackendPrefs() const override;
RenderMode mRenderMode;
private:
void Init();
void InitAcceleration() override;
void InitWebRenderConfig() override;
void InitializeDevices();
void InitializeD3D11();
void InitializeD2D();
bool InitDWriteSupport();
void InitGPUProcessSupport();
void DisableD2D(mozilla::gfx::FeatureStatus aStatus, const char* aMessage,
const nsACString& aFailureId);
void InitializeConfig();
void InitializeD3D9Config();
void InitializeD3D11Config();
void InitializeD2DConfig();
void InitializeDirectDrawConfig();
void RecordStartupTelemetry();
bool mInitializedDevices = false;
// Cached contents of the output color profile file
nsTArray<uint8_t> mCachedOutputColorProfile;
};
#endif /* GFX_WINDOWS_PLATFORM_H */
|
