The Tor Browser / file comparison

comparison: gfx/2d/ScaledFontDWrite.cpp

gfx/2d/ScaledFontDWrite.cpp

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:6146fefca756
1 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
2 * This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5
6 #include "ScaledFontDWrite.h"
7 #include "PathD2D.h"
8 #include "DrawTargetD2D.h"
9 #include "Logging.h"
10
11 #include <vector>
12
13 namespace mozilla {
14 namespace gfx {
15
16 struct ffReferenceKey
17 {
18 uint8_t *mData;
19 uint32_t mSize;
20 };
21
22 class DWriteFontFileLoader : public IDWriteFontFileLoader
23 {
24 public:
25 DWriteFontFileLoader()
26 {
27 }
28
29 // IUnknown interface
30 IFACEMETHOD(QueryInterface)(IID const& iid, OUT void** ppObject)
31 {
32 if (iid == __uuidof(IDWriteFontFileLoader)) {
33 *ppObject = static_cast<IDWriteFontFileLoader*>(this);
34 return S_OK;
35 } else if (iid == __uuidof(IUnknown)) {
36 *ppObject = static_cast<IUnknown*>(this);
37 return S_OK;
38 } else {
39 return E_NOINTERFACE;
40 }
41 }
42
43 IFACEMETHOD_(ULONG, AddRef)()
44 {
45 return 1;
46 }
47
48 IFACEMETHOD_(ULONG, Release)()
49 {
50 return 1;
51 }
52
53 // IDWriteFontFileLoader methods
54 /**
55 * Important! Note the key here -has- to be a pointer to an
56 * ffReferenceKey object.
57 */
58 virtual HRESULT STDMETHODCALLTYPE
59 CreateStreamFromKey(void const* fontFileReferenceKey,
60 UINT32 fontFileReferenceKeySize,
61 OUT IDWriteFontFileStream** fontFileStream);
62
63 /**
64 * Gets the singleton loader instance. Note that when using this font
65 * loader, the key must be a pointer to an FallibleTArray<uint8_t>. This
66 * array will be empty when the function returns.
67 */
68 static IDWriteFontFileLoader* Instance()
69 {
70 if (!mInstance) {
71 mInstance = new DWriteFontFileLoader();
72 DrawTargetD2D::GetDWriteFactory()->
73 RegisterFontFileLoader(mInstance);
74 }
75 return mInstance;
76 }
77
78 private:
79 static IDWriteFontFileLoader* mInstance;
80 };
81
82 class DWriteFontFileStream : public IDWriteFontFileStream
83 {
84 public:
85 /**
86 * Used by the FontFileLoader to create a new font stream,
87 * this font stream is created from data in memory. The memory
88 * passed may be released after object creation, it will be
89 * copied internally.
90 *
91 * @param aData Font data
92 */
93 DWriteFontFileStream(uint8_t *aData, uint32_t aSize);
94 ~DWriteFontFileStream();
95
96 // IUnknown interface
97 IFACEMETHOD(QueryInterface)(IID const& iid, OUT void** ppObject)
98 {
99 if (iid == __uuidof(IDWriteFontFileStream)) {
100 *ppObject = static_cast<IDWriteFontFileStream*>(this);
101 return S_OK;
102 } else if (iid == __uuidof(IUnknown)) {
103 *ppObject = static_cast<IUnknown*>(this);
104 return S_OK;
105 } else {
106 return E_NOINTERFACE;
107 }
108 }
109
110 IFACEMETHOD_(ULONG, AddRef)()
111 {
112 ++mRefCnt;
113 return mRefCnt;
114 }
115
116 IFACEMETHOD_(ULONG, Release)()
117 {
118 --mRefCnt;
119 if (mRefCnt == 0) {
120 delete this;
121 return 0;
122 }
123 return mRefCnt;
124 }
125
126 // IDWriteFontFileStream methods
127 virtual HRESULT STDMETHODCALLTYPE ReadFileFragment(void const** fragmentStart,
128 UINT64 fileOffset,
129 UINT64 fragmentSize,
130 OUT void** fragmentContext);
131
132 virtual void STDMETHODCALLTYPE ReleaseFileFragment(void* fragmentContext);
133
134 virtual HRESULT STDMETHODCALLTYPE GetFileSize(OUT UINT64* fileSize);
135
136 virtual HRESULT STDMETHODCALLTYPE GetLastWriteTime(OUT UINT64* lastWriteTime);
137
138 private:
139 std::vector<uint8_t> mData;
140 uint32_t mRefCnt;
141 };
142
143 static BYTE
144 GetSystemTextQuality()
145 {
146 BOOL font_smoothing;
147 UINT smoothing_type;
148
149 if (!SystemParametersInfo(SPI_GETFONTSMOOTHING, 0, &font_smoothing, 0)) {
150 return DEFAULT_QUALITY;
151 }
152
153 if (font_smoothing) {
154 if (!SystemParametersInfo(SPI_GETFONTSMOOTHINGTYPE,
155 0, &smoothing_type, 0)) {
156 return DEFAULT_QUALITY;
157 }
158
159 if (smoothing_type == FE_FONTSMOOTHINGCLEARTYPE) {
160 return CLEARTYPE_QUALITY;
161 }
162
163 return ANTIALIASED_QUALITY;
164 }
165
166 return DEFAULT_QUALITY;
167 }
168
169 #define GASP_TAG 0x70736167
170 #define GASP_DOGRAY 0x2
171
172 static inline unsigned short
173 readShort(const char *aBuf)
174 {
175 return (*aBuf << 8) | *(aBuf + 1);
176 }
177
178 static bool
179 DoGrayscale(IDWriteFontFace *aDWFace, Float ppem)
180 {
181 void *tableContext;
182 char *tableData;
183 UINT32 tableSize;
184 BOOL exists;
185 aDWFace->TryGetFontTable(GASP_TAG, (const void**)&tableData, &tableSize, &tableContext, &exists);
186
187 if (exists) {
188 if (tableSize < 4) {
189 aDWFace->ReleaseFontTable(tableContext);
190 return true;
191 }
192 struct gaspRange {
193 unsigned short maxPPEM; // Stored big-endian
194 unsigned short behavior; // Stored big-endian
195 };
196 unsigned short numRanges = readShort(tableData + 2);
197 if (tableSize < (UINT)4 + numRanges * 4) {
198 aDWFace->ReleaseFontTable(tableContext);
199 return true;
200 }
201 gaspRange *ranges = (gaspRange *)(tableData + 4);
202 for (int i = 0; i < numRanges; i++) {
203 if (readShort((char*)&ranges[i].maxPPEM) > ppem) {
204 if (!(readShort((char*)&ranges[i].behavior) & GASP_DOGRAY)) {
205 aDWFace->ReleaseFontTable(tableContext);
206 return false;
207 }
208 break;
209 }
210 }
211 aDWFace->ReleaseFontTable(tableContext);
212 }
213 return true;
214 }
215
216 IDWriteFontFileLoader* DWriteFontFileLoader::mInstance = nullptr;
217
218 HRESULT STDMETHODCALLTYPE
219 DWriteFontFileLoader::CreateStreamFromKey(const void *fontFileReferenceKey,
220 UINT32 fontFileReferenceKeySize,
221 IDWriteFontFileStream **fontFileStream)
222 {
223 if (!fontFileReferenceKey || !fontFileStream) {
224 return E_POINTER;
225 }
226
227 const ffReferenceKey *key = static_cast<const ffReferenceKey*>(fontFileReferenceKey);
228 *fontFileStream =
229 new DWriteFontFileStream(key->mData, key->mSize);
230
231 if (!*fontFileStream) {
232 return E_OUTOFMEMORY;
233 }
234 (*fontFileStream)->AddRef();
235 return S_OK;
236 }
237
238 DWriteFontFileStream::DWriteFontFileStream(uint8_t *aData, uint32_t aSize)
239 : mRefCnt(0)
240 {
241 mData.resize(aSize);
242 memcpy(&mData.front(), aData, aSize);
243 }
244
245 DWriteFontFileStream::~DWriteFontFileStream()
246 {
247 }
248
249 HRESULT STDMETHODCALLTYPE
250 DWriteFontFileStream::GetFileSize(UINT64 *fileSize)
251 {
252 *fileSize = mData.size();
253 return S_OK;
254 }
255
256 HRESULT STDMETHODCALLTYPE
257 DWriteFontFileStream::GetLastWriteTime(UINT64 *lastWriteTime)
258 {
259 return E_NOTIMPL;
260 }
261
262 HRESULT STDMETHODCALLTYPE
263 DWriteFontFileStream::ReadFileFragment(const void **fragmentStart,
264 UINT64 fileOffset,
265 UINT64 fragmentSize,
266 void **fragmentContext)
267 {
268 // We are required to do bounds checking.
269 if (fileOffset + fragmentSize > mData.size()) {
270 return E_FAIL;
271 }
272
273 // truncate the 64 bit fileOffset to size_t sized index into mData
274 size_t index = static_cast<size_t>(fileOffset);
275
276 // We should be alive for the duration of this.
277 *fragmentStart = &mData[index];
278 *fragmentContext = nullptr;
279 return S_OK;
280 }
281
282 void STDMETHODCALLTYPE
283 DWriteFontFileStream::ReleaseFileFragment(void *fragmentContext)
284 {
285 }
286
287 ScaledFontDWrite::ScaledFontDWrite(uint8_t *aData, uint32_t aSize,
288 uint32_t aIndex, Float aGlyphSize)
289 : ScaledFontBase(aGlyphSize)
290 {
291 IDWriteFactory *factory = DrawTargetD2D::GetDWriteFactory();
292
293 ffReferenceKey key;
294 key.mData = aData;
295 key.mSize = aSize;
296
297 RefPtr<IDWriteFontFile> fontFile;
298 if (FAILED(factory->CreateCustomFontFileReference(&key, sizeof(ffReferenceKey), DWriteFontFileLoader::Instance(), byRef(fontFile)))) {
299 gfxWarning() << "Failed to load font file from data!";
300 return;
301 }
302
303 IDWriteFontFile *ff = fontFile;
304 if (FAILED(factory->CreateFontFace(DWRITE_FONT_FACE_TYPE_TRUETYPE, 1, &ff, aIndex, DWRITE_FONT_SIMULATIONS_NONE, byRef(mFontFace)))) {
305 gfxWarning() << "Failed to create font face from font file data!";
306 }
307 }
308
309 TemporaryRef<Path>
310 ScaledFontDWrite::GetPathForGlyphs(const GlyphBuffer &aBuffer, const DrawTarget *aTarget)
311 {
312 if (aTarget->GetType() != BackendType::DIRECT2D) {
313 return ScaledFontBase::GetPathForGlyphs(aBuffer, aTarget);
314 }
315
316 RefPtr<PathBuilder> pathBuilder = aTarget->CreatePathBuilder();
317
318 PathBuilderD2D *pathBuilderD2D =
319 static_cast<PathBuilderD2D*>(pathBuilder.get());
320
321 CopyGlyphsToSink(aBuffer, pathBuilderD2D->GetSink());
322
323 return pathBuilder->Finish();
324 }
325
326 void
327 ScaledFontDWrite::CopyGlyphsToBuilder(const GlyphBuffer &aBuffer, PathBuilder *aBuilder, BackendType aBackendType, const Matrix *aTransformHint)
328 {
329 if (aBackendType != BackendType::DIRECT2D) {
330 ScaledFontBase::CopyGlyphsToBuilder(aBuffer, aBuilder, aBackendType, aTransformHint);
331 return;
332 }
333
334 PathBuilderD2D *pathBuilderD2D =
335 static_cast<PathBuilderD2D*>(aBuilder);
336
337 CopyGlyphsToSink(aBuffer, pathBuilderD2D->GetSink());
338 }
339
340 void
341 ScaledFontDWrite::CopyGlyphsToSink(const GlyphBuffer &aBuffer, ID2D1GeometrySink *aSink)
342 {
343 std::vector<UINT16> indices;
344 std::vector<FLOAT> advances;
345 std::vector<DWRITE_GLYPH_OFFSET> offsets;
346 indices.resize(aBuffer.mNumGlyphs);
347 advances.resize(aBuffer.mNumGlyphs);
348 offsets.resize(aBuffer.mNumGlyphs);
349
350 memset(&advances.front(), 0, sizeof(FLOAT) * aBuffer.mNumGlyphs);
351 for (unsigned int i = 0; i < aBuffer.mNumGlyphs; i++) {
352 indices[i] = aBuffer.mGlyphs[i].mIndex;
353 offsets[i].advanceOffset = aBuffer.mGlyphs[i].mPosition.x;
354 offsets[i].ascenderOffset = -aBuffer.mGlyphs[i].mPosition.y;
355 }
356
357 mFontFace->GetGlyphRunOutline(mSize, &indices.front(), &advances.front(),
358 &offsets.front(), aBuffer.mNumGlyphs,
359 FALSE, FALSE, aSink);
360 }
361
362 bool
363 ScaledFontDWrite::GetFontFileData(FontFileDataOutput aDataCallback, void *aBaton)
364 {
365 UINT32 fileCount = 0;
366 mFontFace->GetFiles(&fileCount, nullptr);
367
368 if (fileCount > 1) {
369 MOZ_ASSERT(false);
370 return false;
371 }
372
373 RefPtr<IDWriteFontFile> file;
374 mFontFace->GetFiles(&fileCount, byRef(file));
375
376 const void *referenceKey;
377 UINT32 refKeySize;
378 // XXX - This can currently crash for webfonts, as when we get the reference
379 // key out of the file, that can be an invalid reference key for the loader
380 // we use it with. The fix to this is not obvious but it will probably
381 // have to happen inside thebes.
382 file->GetReferenceKey(&referenceKey, &refKeySize);
383
384 RefPtr<IDWriteFontFileLoader> loader;
385 file->GetLoader(byRef(loader));
386
387 RefPtr<IDWriteFontFileStream> stream;
388 loader->CreateStreamFromKey(referenceKey, refKeySize, byRef(stream));
389
390 UINT64 fileSize64;
391 stream->GetFileSize(&fileSize64);
392 if (fileSize64 > UINT32_MAX) {
393 MOZ_ASSERT(false);
394 return false;
395 }
396
397 uint32_t fileSize = static_cast<uint32_t>(fileSize64);
398 const void *fragmentStart;
399 void *context;
400 stream->ReadFileFragment(&fragmentStart, 0, fileSize, &context);
401
402 aDataCallback((uint8_t*)fragmentStart, fileSize, mFontFace->GetIndex(), mSize, aBaton);
403
404 stream->ReleaseFileFragment(context);
405
406 return true;
407 }
408
409 AntialiasMode
410 ScaledFontDWrite::GetDefaultAAMode()
411 {
412 AntialiasMode defaultMode = AntialiasMode::SUBPIXEL;
413
414 switch (GetSystemTextQuality()) {
415 case CLEARTYPE_QUALITY:
416 defaultMode = AntialiasMode::SUBPIXEL;
417 break;
418 case ANTIALIASED_QUALITY:
419 defaultMode = AntialiasMode::GRAY;
420 break;
421 case DEFAULT_QUALITY:
422 defaultMode = AntialiasMode::NONE;
423 break;
424 }
425
426 if (defaultMode == AntialiasMode::GRAY) {
427 if (!DoGrayscale(mFontFace, mSize)) {
428 defaultMode = AntialiasMode::NONE;
429 }
430 }
431 return defaultMode;
432 }
433
434 }
435 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial