1/* 2 * Copyright (c) 2012 Google Inc. All rights reserved. 3 * Copyright (c) 2014 BlackBerry Limited. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are 7 * met: 8 * 9 * * Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * * Redistributions in binary form must reproduce the above 12 * copyright notice, this list of conditions and the following disclaimer 13 * in the documentation and/or other materials provided with the 14 * distribution. 15 * * Neither the name of Google Inc. nor the names of its 16 * contributors may be used to endorse or promote products derived from 17 * this software without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32#include "config.h" 33#include "platform/fonts/harfbuzz/HarfBuzzFace.h" 34 35#include "SkPaint.h" 36#include "SkPath.h" 37#include "SkPoint.h" 38#include "SkRect.h" 39#include "SkTypeface.h" 40#include "SkUtils.h" 41#include "platform/fonts/FontPlatformData.h" 42#include "platform/fonts/SimpleFontData.h" 43#include "platform/fonts/harfbuzz/HarfBuzzShaper.h" 44 45#include "hb.h" 46#include "wtf/HashMap.h" 47 48namespace blink { 49 50// Our implementation of the callbacks which HarfBuzz requires by using Skia 51// calls. See the HarfBuzz source for references about what these callbacks do. 52 53struct HarfBuzzFontData { 54 HarfBuzzFontData(WTF::HashMap<uint32_t, uint16_t>* glyphCacheForFaceCacheEntry) 55 : m_glyphCacheForFaceCacheEntry(glyphCacheForFaceCacheEntry) 56 { } 57 SkPaint m_paint; 58 WTF::HashMap<uint32_t, uint16_t>* m_glyphCacheForFaceCacheEntry; 59}; 60 61static hb_position_t SkiaScalarToHarfBuzzPosition(SkScalar value) 62{ 63 return SkScalarToFixed(value); 64} 65 66static void SkiaGetGlyphWidthAndExtents(SkPaint* paint, hb_codepoint_t codepoint, hb_position_t* width, hb_glyph_extents_t* extents) 67{ 68 ASSERT(codepoint <= 0xFFFF); 69 paint->setTextEncoding(SkPaint::kGlyphID_TextEncoding); 70 71 SkScalar skWidth; 72 SkRect skBounds; 73 uint16_t glyph = codepoint; 74 75 paint->getTextWidths(&glyph, sizeof(glyph), &skWidth, &skBounds); 76 if (width) 77 *width = SkiaScalarToHarfBuzzPosition(skWidth); 78 if (extents) { 79 // Invert y-axis because Skia is y-grows-down but we set up HarfBuzz to be y-grows-up. 80 extents->x_bearing = SkiaScalarToHarfBuzzPosition(skBounds.fLeft); 81 extents->y_bearing = SkiaScalarToHarfBuzzPosition(-skBounds.fTop); 82 extents->width = SkiaScalarToHarfBuzzPosition(skBounds.width()); 83 extents->height = SkiaScalarToHarfBuzzPosition(-skBounds.height()); 84 } 85} 86 87static hb_bool_t harfBuzzGetGlyph(hb_font_t* hbFont, void* fontData, hb_codepoint_t unicode, hb_codepoint_t variationSelector, hb_codepoint_t* glyph, void* userData) 88{ 89 // Variation selectors not supported. 90 if (variationSelector) 91 return false; 92 93 HarfBuzzFontData* hbFontData = reinterpret_cast<HarfBuzzFontData*>(fontData); 94 95 WTF::HashMap<uint32_t, uint16_t>::AddResult result = hbFontData->m_glyphCacheForFaceCacheEntry->add(unicode, 0); 96 if (result.isNewEntry) { 97 SkPaint* paint = &hbFontData->m_paint; 98 paint->setTextEncoding(SkPaint::kUTF32_TextEncoding); 99 uint16_t glyph16; 100 paint->textToGlyphs(&unicode, sizeof(hb_codepoint_t), &glyph16); 101 result.storedValue->value = glyph16; 102 *glyph = glyph16; 103 } 104 *glyph = result.storedValue->value; 105 return !!*glyph; 106} 107 108static hb_position_t harfBuzzGetGlyphHorizontalAdvance(hb_font_t* hbFont, void* fontData, hb_codepoint_t glyph, void* userData) 109{ 110 HarfBuzzFontData* hbFontData = reinterpret_cast<HarfBuzzFontData*>(fontData); 111 hb_position_t advance = 0; 112 113 SkiaGetGlyphWidthAndExtents(&hbFontData->m_paint, glyph, &advance, 0); 114 return advance; 115} 116 117static hb_bool_t harfBuzzGetGlyphHorizontalOrigin(hb_font_t* hbFont, void* fontData, hb_codepoint_t glyph, hb_position_t* x, hb_position_t* y, void* userData) 118{ 119 // Just return true, following the way that HarfBuzz-FreeType 120 // implementation does. 121 return true; 122} 123 124static hb_position_t harfBuzzGetGlyphHorizontalKerning(hb_font_t*, void* fontData, hb_codepoint_t leftGlyph, hb_codepoint_t rightGlyph, void*) 125{ 126 HarfBuzzFontData* hbFontData = reinterpret_cast<HarfBuzzFontData*>(fontData); 127 if (hbFontData->m_paint.isVerticalText()) { 128 // We don't support cross-stream kerning 129 return 0; 130 } 131 132 SkTypeface* typeface = hbFontData->m_paint.getTypeface(); 133 134 const uint16_t glyphs[2] = { static_cast<uint16_t>(leftGlyph), static_cast<uint16_t>(rightGlyph) }; 135 int32_t kerningAdjustments[1] = { 0 }; 136 137 if (typeface->getKerningPairAdjustments(glyphs, 2, kerningAdjustments)) { 138 SkScalar upm = SkIntToScalar(typeface->getUnitsPerEm()); 139 SkScalar size = hbFontData->m_paint.getTextSize(); 140 return SkiaScalarToHarfBuzzPosition(SkScalarMulDiv(SkIntToScalar(kerningAdjustments[0]), size, upm)); 141 } 142 143 return 0; 144} 145 146static hb_position_t harfBuzzGetGlyphVerticalKerning(hb_font_t*, void* fontData, hb_codepoint_t topGlyph, hb_codepoint_t bottomGlyph, void*) 147{ 148 HarfBuzzFontData* hbFontData = reinterpret_cast<HarfBuzzFontData*>(fontData); 149 if (!hbFontData->m_paint.isVerticalText()) { 150 // We don't support cross-stream kerning 151 return 0; 152 } 153 154 SkTypeface* typeface = hbFontData->m_paint.getTypeface(); 155 156 const uint16_t glyphs[2] = { static_cast<uint16_t>(topGlyph), static_cast<uint16_t>(bottomGlyph) }; 157 int32_t kerningAdjustments[1] = { 0 }; 158 159 if (typeface->getKerningPairAdjustments(glyphs, 2, kerningAdjustments)) { 160 SkScalar upm = SkIntToScalar(typeface->getUnitsPerEm()); 161 SkScalar size = hbFontData->m_paint.getTextSize(); 162 return SkiaScalarToHarfBuzzPosition(SkScalarMulDiv(SkIntToScalar(kerningAdjustments[0]), size, upm)); 163 } 164 165 return 0; 166} 167 168static hb_bool_t harfBuzzGetGlyphExtents(hb_font_t* hbFont, void* fontData, hb_codepoint_t glyph, hb_glyph_extents_t* extents, void* userData) 169{ 170 HarfBuzzFontData* hbFontData = reinterpret_cast<HarfBuzzFontData*>(fontData); 171 172 SkiaGetGlyphWidthAndExtents(&hbFontData->m_paint, glyph, 0, extents); 173 return true; 174} 175 176static hb_font_funcs_t* harfBuzzSkiaGetFontFuncs() 177{ 178 static hb_font_funcs_t* harfBuzzSkiaFontFuncs = 0; 179 180 // We don't set callback functions which we can't support. 181 // HarfBuzz will use the fallback implementation if they aren't set. 182 if (!harfBuzzSkiaFontFuncs) { 183 harfBuzzSkiaFontFuncs = hb_font_funcs_create(); 184 hb_font_funcs_set_glyph_func(harfBuzzSkiaFontFuncs, harfBuzzGetGlyph, 0, 0); 185 hb_font_funcs_set_glyph_h_advance_func(harfBuzzSkiaFontFuncs, harfBuzzGetGlyphHorizontalAdvance, 0, 0); 186 hb_font_funcs_set_glyph_h_kerning_func(harfBuzzSkiaFontFuncs, harfBuzzGetGlyphHorizontalKerning, 0, 0); 187 hb_font_funcs_set_glyph_h_origin_func(harfBuzzSkiaFontFuncs, harfBuzzGetGlyphHorizontalOrigin, 0, 0); 188 hb_font_funcs_set_glyph_v_kerning_func(harfBuzzSkiaFontFuncs, harfBuzzGetGlyphVerticalKerning, 0, 0); 189 hb_font_funcs_set_glyph_extents_func(harfBuzzSkiaFontFuncs, harfBuzzGetGlyphExtents, 0, 0); 190 hb_font_funcs_make_immutable(harfBuzzSkiaFontFuncs); 191 } 192 return harfBuzzSkiaFontFuncs; 193} 194 195static hb_blob_t* harfBuzzSkiaGetTable(hb_face_t* face, hb_tag_t tag, void* userData) 196{ 197 SkTypeface* typeface = reinterpret_cast<SkTypeface*>(userData); 198 199 const size_t tableSize = typeface->getTableSize(tag); 200 if (!tableSize) 201 return 0; 202 203 char* buffer = reinterpret_cast<char*>(fastMalloc(tableSize)); 204 if (!buffer) 205 return 0; 206 size_t actualSize = typeface->getTableData(tag, 0, tableSize, buffer); 207 if (tableSize != actualSize) { 208 fastFree(buffer); 209 return 0; 210 } 211 212 return hb_blob_create(const_cast<char*>(buffer), tableSize, HB_MEMORY_MODE_WRITABLE, buffer, fastFree); 213} 214 215static void destroyHarfBuzzFontData(void* userData) 216{ 217 HarfBuzzFontData* hbFontData = reinterpret_cast<HarfBuzzFontData*>(userData); 218 delete hbFontData; 219} 220 221hb_face_t* HarfBuzzFace::createFace() 222{ 223 hb_face_t* face = hb_face_create_for_tables(harfBuzzSkiaGetTable, m_platformData->typeface(), 0); 224 ASSERT(face); 225 return face; 226} 227 228hb_font_t* HarfBuzzFace::createFont() 229{ 230 HarfBuzzFontData* hbFontData = new HarfBuzzFontData(m_glyphCacheForFaceCacheEntry); 231 m_platformData->setupPaint(&hbFontData->m_paint); 232 hb_font_t* font = hb_font_create(m_face); 233 hb_font_set_funcs(font, harfBuzzSkiaGetFontFuncs(), hbFontData, destroyHarfBuzzFontData); 234 float size = m_platformData->size(); 235 int scale = SkiaScalarToHarfBuzzPosition(size); 236 hb_font_set_scale(font, scale, scale); 237 hb_font_make_immutable(font); 238 return font; 239} 240 241} // namespace blink 242