645cd173528d18cce8e12c47d3994598d076b914
[WebKit-https.git] / Source / WebCore / platform / graphics / freetype / FontPlatformDataFreeType.cpp
1 /*
2  * Copyright (C) 2006 Apple Inc.
3  * Copyright (C) 2006 Michael Emmel mike.emmel@gmail.com
4  * Copyright (C) 2007, 2008 Alp Toker <alp@atoker.com>
5  * Copyright (C) 2007 Holger Hans Peter Freyther
6  * Copyright (C) 2009, 2010 Igalia S.L.
7  * All rights reserved.
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Library General Public
11  * License as published by the Free Software Foundation; either
12  * version 2 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Library General Public License for more details.
18  *
19  * You should have received a copy of the GNU Library General Public License
20  * along with this library; see the file COPYING.LIB.  If not, write to
21  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
22  * Boston, MA 02110-1301, USA.
23  */
24
25 #include "config.h"
26 #include "FontPlatformData.h"
27
28 #include "CairoUniquePtr.h"
29 #include "CairoUtilities.h"
30 #include "FontCache.h"
31 #include "SharedBuffer.h"
32 #include <cairo-ft.h>
33 #include <fontconfig/fcfreetype.h>
34 #include <ft2build.h>
35 #include FT_TRUETYPE_TABLES_H
36 #include <hb-ft.h>
37 #include <hb-ot.h>
38 #include <wtf/MathExtras.h>
39 #include <wtf/text/WTFString.h>
40
41 namespace WebCore {
42
43 static cairo_subpixel_order_t convertFontConfigSubpixelOrder(int fontConfigOrder)
44 {
45     switch (fontConfigOrder) {
46     case FC_RGBA_RGB:
47         return CAIRO_SUBPIXEL_ORDER_RGB;
48     case FC_RGBA_BGR:
49         return CAIRO_SUBPIXEL_ORDER_BGR;
50     case FC_RGBA_VRGB:
51         return CAIRO_SUBPIXEL_ORDER_VRGB;
52     case FC_RGBA_VBGR:
53         return CAIRO_SUBPIXEL_ORDER_VBGR;
54     case FC_RGBA_NONE:
55     case FC_RGBA_UNKNOWN:
56         return CAIRO_SUBPIXEL_ORDER_DEFAULT;
57     }
58     return CAIRO_SUBPIXEL_ORDER_DEFAULT;
59 }
60
61 static cairo_hint_style_t convertFontConfigHintStyle(int fontConfigStyle)
62 {
63     switch (fontConfigStyle) {
64     case FC_HINT_NONE:
65         return CAIRO_HINT_STYLE_NONE;
66     case FC_HINT_SLIGHT:
67         return CAIRO_HINT_STYLE_SLIGHT;
68     case FC_HINT_MEDIUM:
69         return CAIRO_HINT_STYLE_MEDIUM;
70     case FC_HINT_FULL:
71         return CAIRO_HINT_STYLE_FULL;
72     }
73     return CAIRO_HINT_STYLE_NONE;
74 }
75
76 static void setCairoFontOptionsFromFontConfigPattern(cairo_font_options_t* options, FcPattern* pattern)
77 {
78     FcBool booleanResult;
79     int integerResult;
80
81     if (FcPatternGetInteger(pattern, FC_RGBA, 0, &integerResult) == FcResultMatch) {
82         cairo_font_options_set_subpixel_order(options, convertFontConfigSubpixelOrder(integerResult));
83
84         // Based on the logic in cairo-ft-font.c in the cairo source, a font with
85         // a subpixel order implies that is uses subpixel antialiasing.
86         if (integerResult != FC_RGBA_NONE)
87             cairo_font_options_set_antialias(options, CAIRO_ANTIALIAS_SUBPIXEL);
88     }
89
90     if (FcPatternGetBool(pattern, FC_ANTIALIAS, 0, &booleanResult) == FcResultMatch) {
91         // Only override the anti-aliasing setting if was previously turned off. Otherwise
92         // we'll override the preference which decides between gray anti-aliasing and
93         // subpixel anti-aliasing.
94         if (!booleanResult)
95             cairo_font_options_set_antialias(options, CAIRO_ANTIALIAS_NONE);
96         else if (cairo_font_options_get_antialias(options) == CAIRO_ANTIALIAS_NONE)
97             cairo_font_options_set_antialias(options, CAIRO_ANTIALIAS_GRAY);
98     }
99
100     if (FcPatternGetInteger(pattern, FC_HINT_STYLE, 0, &integerResult) == FcResultMatch)
101         cairo_font_options_set_hint_style(options, convertFontConfigHintStyle(integerResult));
102     if (FcPatternGetBool(pattern, FC_HINTING, 0, &booleanResult) == FcResultMatch && !booleanResult)
103         cairo_font_options_set_hint_style(options, CAIRO_HINT_STYLE_NONE);
104
105 #if ENABLE(VARIATION_FONTS)
106     FcChar8* variations;
107     if (FcPatternGetString(pattern, FC_FONT_VARIATIONS, 0, &variations) == FcResultMatch) {
108         cairo_font_options_set_variations(options, reinterpret_cast<char*>(variations));
109     }
110 #endif
111 }
112
113 FontPlatformData::FontPlatformData(cairo_font_face_t* fontFace, FcPattern* pattern, float size, bool fixedWidth, bool syntheticBold, bool syntheticOblique, FontOrientation orientation)
114     : FontPlatformData(size, syntheticBold, syntheticOblique, orientation)
115 {
116     m_pattern = pattern;
117     m_fixedWidth = fixedWidth;
118
119     buildScaledFont(fontFace);
120 }
121
122 FontPlatformData::FontPlatformData(const FontPlatformData& other)
123 {
124     *this = other;
125 }
126
127 FontPlatformData& FontPlatformData::operator=(const FontPlatformData& other)
128 {
129     // Check for self-assignment.
130     if (this == &other)
131         return *this;
132
133     m_size = other.m_size;
134     m_orientation = other.m_orientation;
135     m_widthVariant = other.m_widthVariant;
136     m_textRenderingMode = other.m_textRenderingMode;
137
138     m_syntheticBold = other.m_syntheticBold;
139     m_syntheticOblique = other.m_syntheticOblique;
140     m_isColorBitmapFont = other.m_isColorBitmapFont;
141     m_isHashTableDeletedValue = other.m_isHashTableDeletedValue;
142     m_isSystemFont = other.m_isSystemFont;
143
144     m_fixedWidth = other.m_fixedWidth;
145     m_pattern = other.m_pattern;
146
147     m_scaledFont = other.m_scaledFont;
148
149     return *this;
150 }
151
152 FontPlatformData::~FontPlatformData() = default;
153
154 FontPlatformData FontPlatformData::cloneWithOrientation(const FontPlatformData& source, FontOrientation orientation)
155 {
156     FontPlatformData copy(source);
157     if (copy.m_scaledFont && copy.m_orientation != orientation) {
158         copy.m_orientation = orientation;
159         copy.buildScaledFont(cairo_scaled_font_get_font_face(copy.m_scaledFont.get()));
160     }
161     return copy;
162 }
163
164 FontPlatformData FontPlatformData::cloneWithSyntheticOblique(const FontPlatformData& source, bool syntheticOblique)
165 {
166     FontPlatformData copy(source);
167     if (copy.m_syntheticOblique != syntheticOblique) {
168         copy.m_syntheticOblique = syntheticOblique;
169         ASSERT(copy.m_scaledFont.get());
170         copy.buildScaledFont(cairo_scaled_font_get_font_face(copy.m_scaledFont.get()));
171     }
172     return copy;
173 }
174
175 FontPlatformData FontPlatformData::cloneWithSize(const FontPlatformData& source, float size)
176 {
177     FontPlatformData copy(source);
178     copy.m_size = size;
179     // We need to reinitialize the instance, because the difference in size
180     // necessitates a new scaled font instance.
181     ASSERT(copy.m_scaledFont.get());
182     copy.buildScaledFont(cairo_scaled_font_get_font_face(copy.m_scaledFont.get()));
183     return copy;
184 }
185
186 FcPattern* FontPlatformData::fcPattern() const
187 {
188     return m_pattern.get();
189 }
190
191 bool FontPlatformData::isFixedPitch() const
192 {
193     return m_fixedWidth;
194 }
195
196 unsigned FontPlatformData::hash() const
197 {
198     return PtrHash<cairo_scaled_font_t*>::hash(m_scaledFont.get());
199 }
200
201 bool FontPlatformData::platformIsEqual(const FontPlatformData& other) const
202 {
203     // FcPatternEqual does not support null pointers as arguments.
204     if ((m_pattern && !other.m_pattern)
205         || (!m_pattern && other.m_pattern)
206         || (m_pattern != other.m_pattern && !FcPatternEqual(m_pattern.get(), other.m_pattern.get())))
207         return false;
208
209     return m_scaledFont == other.m_scaledFont;
210 }
211
212 #if !LOG_DISABLED
213 String FontPlatformData::description() const
214 {
215     return String();
216 }
217 #endif
218
219 void FontPlatformData::buildScaledFont(cairo_font_face_t* fontFace)
220 {
221     ASSERT(m_pattern);
222     CairoUniquePtr<cairo_font_options_t> options(cairo_font_options_copy(getDefaultCairoFontOptions()));
223     setCairoFontOptionsFromFontConfigPattern(options.get(), m_pattern.get());
224
225     cairo_matrix_t ctm;
226     cairo_matrix_init_identity(&ctm);
227
228     // FontConfig may return a list of transformation matrices with the pattern, for instance,
229     // for fonts that are oblique. We use that to initialize the cairo font matrix.
230     cairo_matrix_t fontMatrix;
231     FcMatrix fontConfigMatrix, *tempFontConfigMatrix;
232     FcMatrixInit(&fontConfigMatrix);
233
234     // These matrices may be stacked in the pattern, so it's our job to get them all and multiply them.
235     for (int i = 0; FcPatternGetMatrix(m_pattern.get(), FC_MATRIX, i, &tempFontConfigMatrix) == FcResultMatch; i++)
236         FcMatrixMultiply(&fontConfigMatrix, &fontConfigMatrix, tempFontConfigMatrix);
237
238     cairo_matrix_init(&fontMatrix, 1, -fontConfigMatrix.yx, -fontConfigMatrix.xy, 1, 0, 0);
239
240     // The matrix from FontConfig does not include the scale. Scaling a font with width zero size leads
241     // to a failed cairo_scaled_font_t instantiations. Instead we scale the font to a very tiny
242     // size and just abort rendering later on.
243     float realSize = m_size ? m_size : 1;
244     cairo_matrix_scale(&fontMatrix, realSize, realSize);
245
246     if (syntheticOblique()) {
247         static const float syntheticObliqueSkew = -tanf(14 * acosf(0) / 90);
248         static const cairo_matrix_t skew = {1, 0, syntheticObliqueSkew, 1, 0, 0};
249         static const cairo_matrix_t verticalSkew = {1, -syntheticObliqueSkew, 0, 1, 0, 0};
250         cairo_matrix_multiply(&fontMatrix, m_orientation == FontOrientation::Vertical ? &verticalSkew : &skew, &fontMatrix);
251     }
252
253     if (m_orientation == FontOrientation::Vertical) {
254         // The resulting transformation matrix for vertical glyphs (V) is a
255         // combination of rotation (R) and translation (T) applied on the
256         // horizontal matrix (H). V = H . R . T, where R rotates by -90 degrees
257         // and T translates by font size towards y axis.
258         cairo_matrix_rotate(&fontMatrix, -piOverTwoDouble);
259         cairo_matrix_translate(&fontMatrix, 0.0, 1.0);
260     }
261
262     m_scaledFont = adoptRef(cairo_scaled_font_create(fontFace, &fontMatrix, &ctm, options.get()));
263 }
264
265 bool FontPlatformData::hasCompatibleCharmap() const
266 {
267     ASSERT(m_scaledFont.get());
268     CairoFtFaceLocker cairoFtFaceLocker(m_scaledFont.get());
269     FT_Face freeTypeFace = cairoFtFaceLocker.ftFace();
270     if (!freeTypeFace)
271         return false;
272     return !(FT_Select_Charmap(freeTypeFace, ft_encoding_unicode)
273         && FT_Select_Charmap(freeTypeFace, ft_encoding_symbol)
274         && FT_Select_Charmap(freeTypeFace, ft_encoding_apple_roman));
275 }
276
277 RefPtr<SharedBuffer> FontPlatformData::openTypeTable(uint32_t table) const
278 {
279     CairoFtFaceLocker cairoFtFaceLocker(m_scaledFont.get());
280     FT_Face freeTypeFace = cairoFtFaceLocker.ftFace();
281     if (!freeTypeFace)
282         return nullptr;
283
284     FT_ULong tableSize = 0;
285     // Tag bytes need to be reversed because OT_MAKE_TAG uses big-endian order.
286     uint32_t tag = FT_MAKE_TAG((table & 0xff), (table & 0xff00) >> 8, (table & 0xff0000) >> 16, table >> 24);
287     if (FT_Load_Sfnt_Table(freeTypeFace, tag, 0, 0, &tableSize))
288         return nullptr;
289
290     Vector<char> data(tableSize);
291     FT_ULong expectedTableSize = tableSize;
292     FT_Error error = FT_Load_Sfnt_Table(freeTypeFace, tag, 0, reinterpret_cast<FT_Byte*>(data.data()), &tableSize);
293     if (error || tableSize != expectedTableSize)
294         return nullptr;
295
296     return SharedBuffer::create(WTFMove(data));
297 }
298
299 HbUniquePtr<hb_font_t> FontPlatformData::createOpenTypeMathHarfBuzzFont() const
300 {
301     CairoFtFaceLocker cairoFtFaceLocker(m_scaledFont.get());
302     FT_Face ftFace = cairoFtFaceLocker.ftFace();
303     if (!ftFace)
304         return nullptr;
305
306     HbUniquePtr<hb_face_t> face(hb_ft_face_create_cached(ftFace));
307     if (!hb_ot_math_has_data(face.get()))
308         return nullptr;
309
310     return HbUniquePtr<hb_font_t>(hb_font_create(face.get()));
311 }
312
313 } // namespace WebCore