LayoutEngine::LayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags, LEErrorCode &success) : fHbFont(NULL), fHbBuffer(NULL), fTypoFlags(typoFlags) { if (LE_FAILURE(success)) { return; } fHbBuffer = hb_buffer_create (); if (fHbBuffer == hb_buffer_get_empty ()) { success = LE_MEMORY_ALLOCATION_ERROR; return; } hb_buffer_set_unicode_funcs (fHbBuffer, hb_icu_get_unicode_funcs ()); hb_buffer_set_script (fHbBuffer, hb_icu_script_to_script ((UScriptCode) scriptCode)); /* TODO set language */ hb_face_t *face = hb_face_create_for_tables (icu_le_hb_reference_table, (void *) fontInstance, NULL); fHbFont = hb_font_create (face); hb_face_destroy (face); if (fHbFont == hb_font_get_empty ()) { success = LE_MEMORY_ALLOCATION_ERROR; return; } hb_font_set_funcs (fHbFont, icu_le_hb_get_font_funcs (), (void *) fontInstance, NULL); hb_font_set_scale (fHbFont, +from_float (fontInstance->getXPixelsPerEm () * fontInstance->getScaleFactorX ()), -from_float (fontInstance->getYPixelsPerEm () * fontInstance->getScaleFactorY ())); hb_font_set_ppem (fHbFont, fontInstance->getXPixelsPerEm (), fontInstance->getYPixelsPerEm ()); }
void* ScFace::ScFaceData::hbFont() { if (!m_hbFont) { if (!ftFace()) return NULL; if (formatCode == ScFace::SFNT || formatCode == ScFace::TTCF || formatCode == ScFace::TYPE42) { // use HarfBuzz internal font functions for formats it supports, // gives us more consistent glyph metrics. FT_Reference_Face(ftFace()); hb_face_t *hbFace = hb_face_create_for_tables(referenceTable, ftFace(), (hb_destroy_func_t) FT_Done_Face); hb_face_set_index(hbFace, ftFace()->face_index); hb_face_set_upem(hbFace, ftFace()->units_per_EM); m_hbFont = hb_font_create(hbFace); hb_ot_font_set_funcs(reinterpret_cast<hb_font_t*>(m_hbFont)); hb_face_destroy(hbFace); } else { m_hbFont = hb_ft_font_create_referenced(ftFace()); } } return m_hbFont; }
SkShaper::SkShaper(sk_sp<SkTypeface> tf) : fImpl(new Impl) { fImpl->fTypeface = tf ? std::move(tf) : SkTypeface::MakeDefault(); int index; std::unique_ptr<SkStreamAsset> asset(fImpl->fTypeface->openStream(&index)); size_t size = asset->getLength(); SkAutoMalloc autoMalloc(size); // TODO(halcanary): Avoid this malloc+copy. asset->read(autoMalloc.get(), size); asset = nullptr; void* ptr = autoMalloc.get(); hb_blob_t* blob = hb_blob_create((char*)autoMalloc.release(), size, HB_MEMORY_MODE_READONLY, ptr, sk_free); SkASSERT(blob); hb_blob_make_immutable(blob); struct HBFaceDel { void operator()(hb_face_t* f) { hb_face_destroy(f); } }; std::unique_ptr<hb_face_t, HBFaceDel> face(hb_face_create(blob, (unsigned)index)); hb_blob_destroy(blob); SkASSERT(face); if (!face) { return; } hb_face_set_index(face.get(), (unsigned)index); hb_face_set_upem(face.get(), fImpl->fTypeface->getUnitsPerEm()); fImpl->fHarfBuzzFont.reset(hb_font_create(face.get())); SkASSERT(fImpl->fHarfBuzzFont); hb_font_set_scale(fImpl->fHarfBuzzFont.get(), FONT_SIZE_SCALE, FONT_SIZE_SCALE); hb_ot_font_set_funcs(fImpl->fHarfBuzzFont.get()); fImpl->fBuffer.reset(hb_buffer_create()); }
static void * create_font (void) { hb_face_t *face = (hb_face_t *) create_face (); hb_font_t *font = hb_font_create (face); hb_face_destroy (face); return font; }
hb_font_t* HarfBuzzFace::createFont() { hb_font_t* font = hb_font_create(m_face); hb_font_set_funcs(font, harfBuzzCoreTextGetFontFuncs(), m_platformData, 0); const float size = m_platformData->m_size; hb_font_set_ppem(font, size, size); const int scale = (1 << 16) * static_cast<int>(size); hb_font_set_scale(font, scale, scale); hb_font_make_immutable(font); return font; }
hb_font_t* HarfBuzzFace::createFont() { HarfBuzzFontData* hbFontData = new HarfBuzzFontData(m_glyphCacheForFaceCacheEntry); m_platformData->setupPaint(&hbFontData->m_paint); hb_font_t* font = hb_font_create(m_face); hb_font_set_funcs(font, harfBuzzSkiaGetFontFuncs(), hbFontData, destroyHarfBuzzFontData); float size = m_platformData->size(); int scale = SkiaScalarToHarfBuzzPosition(size); hb_font_set_scale(font, scale, scale); hb_font_make_immutable(font); return font; }
int glyphwidth (lua_State* L) { size_t font_l; unsigned int gid = luaL_checknumber(L, 1); const char * font_s = luaL_checklstring(L, 2, &font_l); unsigned int font_index = luaL_checknumber(L, 3); hb_blob_t* blob = hb_blob_create (font_s, font_l, HB_MEMORY_MODE_WRITABLE, (void*)font_s, NULL); hb_face_t* hbFace = hb_face_create (blob, font_index); hb_font_t* hbFont = hb_font_create (hbFace); short upem = hb_face_get_upem(hbFace); hb_ft_font_set_funcs(hbFont); hb_position_t width = hb_font_get_glyph_h_advance(hbFont, gid); lua_pushnumber(L, width / (double)upem); return 1; }
hb_font_t* createFont(hb_face_t* face, SkPaint* paint, float sizeX, float sizeY) { hb_font_t* font = hb_font_create(face); // Note: this needs to be reworked when we do subpixels int x_ppem = floor(sizeX + 0.5); int y_ppem = floor(sizeY + 0.5); hb_font_set_ppem(font, x_ppem, y_ppem); hb_font_set_scale(font, HBFloatToFixed(sizeX), HBFloatToFixed(sizeY)); HarfBuzzFontData* data = new HarfBuzzFontData(paint); hb_font_set_funcs(font, harfbuzzSkiaGetFontFuncs(), data, destroyHarfBuzzFontData); return font; }
hb_font_t* HarfBuzzFace::createFont() { hb_font_t* font = hb_font_create(m_face); SkPaint* paint = new SkPaint; m_platformData->setupPaint(paint); hb_font_set_funcs(font, harfbuzzSkiaGetFontFuncs(), paint, destroyPaint); float size = m_platformData->size(); if (floorf(size) == size) hb_font_set_ppem(font, size, size); int scale = SkiaScalarToHarfbuzzPosition(size); hb_font_set_scale(font, scale, scale); hb_font_make_immutable(font); return font; }
int get_typographic_extents (lua_State *L) { size_t font_l; const char * font_s = luaL_checklstring(L, 1, &font_l); unsigned int font_index = luaL_checknumber(L, 2); short upem; double ascender; double descender; double x_height; #ifdef USE_FREETYPE_METRICS if (!library) FT_Init_FreeType (&library); FT_Face ft_face = NULL; FT_Error err = FT_New_Memory_Face (library, (const FT_Byte *) font_s, font_l, font_index, &ft_face); if(err) { luaL_error(L, "FT_New_Memory_Face failed"); } upem = ft_face->units_per_EM; ascender = ft_face->ascender / (double)upem; descender = -ft_face->descender / (double)upem; TT_OS2* os2 = (TT_OS2*) FT_Get_Sfnt_Table(ft_face, ft_sfnt_os2); if (os2) { x_height = os2->sxHeight / (double)upem; } FT_Done_Face(ft_face); #else hb_blob_t* blob = hb_blob_create (font_s, font_l, HB_MEMORY_MODE_WRITABLE, (void*)font_s, NULL); hb_face_t* hbFace = hb_face_create (blob, font_index); hb_font_t* hbFont = hb_font_create (hbFace); hb_font_extents_t metrics = {0,0,0}; upem = hb_face_get_upem(hbFace); hb_ft_font_set_funcs(hbFont); hb_font_get_h_extents(hbFont, &metrics); ascender = metrics.ascender / (double)upem; descender = metrics.descender / (double)upem; hb_font_destroy(hbFont); #endif lua_newtable(L); lua_pushstring(L, "ascender"); lua_pushnumber(L, ascender); lua_settable(L, -3); lua_pushstring(L, "x_height"); lua_pushnumber(L, x_height); lua_settable(L, -3); lua_pushstring(L, "descender"); lua_pushnumber(L, descender); lua_settable(L, -3); return 1; }
void XeTeXFontInst::initialize(const char* pathname, int index, int &status) { TT_Postscript *postTable; TT_OS2* os2Table; FT_Error error; hb_face_t *hbFace; if (!gFreeTypeLibrary) { error = FT_Init_FreeType(&gFreeTypeLibrary); if (error) { fprintf(stderr, "FreeType initialization failed! (%d)\n", error); exit(1); } } error = FT_New_Face(gFreeTypeLibrary, pathname, index, &m_ftFace); if (error) { status = 1; return; } if (!FT_IS_SCALABLE(m_ftFace)) { status = 1; return; } /* for non-sfnt-packaged fonts (presumably Type 1), see if there is an AFM file we can attach */ if (index == 0 && !FT_IS_SFNT(m_ftFace)) { char* afm = xstrdup (xbasename (pathname)); char* p = strrchr (afm, '.'); if (p != NULL && strlen(p) == 4 && tolower(*(p+1)) == 'p' && tolower(*(p+2)) == 'f') strcpy(p, ".afm"); char *fullafm = kpse_find_file (afm, kpse_afm_format, 0); free (afm); if (fullafm) { FT_Attach_File(m_ftFace, fullafm); free (fullafm); } } m_filename = xstrdup(pathname); m_index = index; m_unitsPerEM = m_ftFace->units_per_EM; m_ascent = unitsToPoints(m_ftFace->ascender); m_descent = unitsToPoints(m_ftFace->descender); postTable = (TT_Postscript *) getFontTable(ft_sfnt_post); if (postTable != NULL) { m_italicAngle = Fix2D(postTable->italicAngle); } os2Table = (TT_OS2*) getFontTable(ft_sfnt_os2); if (os2Table) { m_capHeight = unitsToPoints(os2Table->sCapHeight); m_xHeight = unitsToPoints(os2Table->sxHeight); } // Set up HarfBuzz font hbFace = hb_face_create_for_tables(_get_table, m_ftFace, NULL); hb_face_set_index(hbFace, index); hb_face_set_upem(hbFace, m_unitsPerEM); m_hbFont = hb_font_create(hbFace); hb_face_destroy(hbFace); if (hbFontFuncs == NULL) hbFontFuncs = _get_font_funcs(); hb_font_set_funcs(m_hbFont, hbFontFuncs, m_ftFace, NULL); hb_font_set_scale(m_hbFont, m_unitsPerEM, m_unitsPerEM); // We don’t want device tables adjustments hb_font_set_ppem(m_hbFont, 0, 0); return; }
int shape (lua_State *L) { size_t font_l; const char * text = luaL_checkstring(L, 1); const char * font_s = luaL_checklstring(L, 2, &font_l); unsigned int font_index = luaL_checknumber(L, 3); const char * script = luaL_checkstring(L, 4); const char * direction_s = luaL_checkstring(L, 5); const char * lang = luaL_checkstring(L, 6); double point_size = luaL_checknumber(L, 7); const char * featurestring = luaL_checkstring(L, 8); hb_segment_properties_t segment_props; hb_shape_plan_t *shape_plan; hb_direction_t direction; hb_feature_t* features; int nFeatures = 0; unsigned int glyph_count = 0; hb_font_t *hbFont; hb_buffer_t *buf; hb_glyph_info_t *glyph_info; hb_glyph_position_t *glyph_pos; unsigned int j; features = scan_feature_string(featurestring, &nFeatures); if (!strcasecmp(direction_s,"RTL")) direction = HB_DIRECTION_RTL; else if (!strcasecmp(direction_s,"TTB")) direction = HB_DIRECTION_TTB; else direction = HB_DIRECTION_LTR; hb_blob_t* blob = hb_blob_create (font_s, font_l, HB_MEMORY_MODE_WRITABLE, (void*)font_s, NULL); hb_face_t* hbFace = hb_face_create (blob, font_index); hbFont = hb_font_create (hbFace); unsigned int upem = hb_face_get_upem(hbFace); hb_font_set_scale(hbFont, upem, upem); /* Harfbuzz's support for OT fonts is great, but there's currently no support for CFF fonts, so downgrade to Freetype for those. */ if (strncmp(font_s, "OTTO", 4) == 0) { hb_ft_font_set_funcs(hbFont); } else { hb_ot_font_set_funcs(hbFont); } buf = hb_buffer_create(); hb_buffer_add_utf8(buf, text, strlen(text), 0, strlen(text)); hb_buffer_set_script(buf, hb_tag_from_string(script, strlen(script))); hb_buffer_set_direction(buf, direction); hb_buffer_set_language(buf, hb_language_from_string(lang,strlen(lang))); hb_buffer_guess_segment_properties(buf); hb_buffer_get_segment_properties(buf, &segment_props); shape_plan = hb_shape_plan_create_cached(hbFace, &segment_props, features, nFeatures, NULL); int res = hb_shape_plan_execute(shape_plan, hbFont, buf, features, nFeatures); if (direction == HB_DIRECTION_RTL) { hb_buffer_reverse(buf); /* URGH */ } glyph_info = hb_buffer_get_glyph_infos(buf, &glyph_count); glyph_pos = hb_buffer_get_glyph_positions(buf, &glyph_count); lua_checkstack(L, glyph_count); for (j = 0; j < glyph_count; ++j) { char namebuf[255]; hb_glyph_extents_t extents = {0,0,0,0}; hb_font_get_glyph_extents(hbFont, glyph_info[j].codepoint, &extents); lua_newtable(L); lua_pushstring(L, "name"); hb_font_get_glyph_name( hbFont, glyph_info[j].codepoint, namebuf, 255 ); lua_pushstring(L, namebuf); lua_settable(L, -3); /* We don't apply x-offset and y-offsets for TTB, which is arguably a bug. We should. The reason we don't is that Harfbuzz assumes that you want to shift the character from a top-center baseline to a bottom-left baseline, and gives you offsets which do that. We don't want to do that so we ignore the offsets. I'm told there is a way of configuring HB's idea of the baseline, and we should use that and take out this condition. */ if (direction != HB_DIRECTION_TTB) { if (glyph_pos[j].x_offset) { lua_pushstring(L, "x_offset"); lua_pushnumber(L, glyph_pos[j].x_offset * point_size / upem); lua_settable(L, -3); } if (glyph_pos[j].y_offset) { lua_pushstring(L, "y_offset"); lua_pushnumber(L, glyph_pos[j].y_offset * point_size / upem); lua_settable(L, -3); } } lua_pushstring(L, "codepoint"); lua_pushinteger(L, glyph_info[j].codepoint); lua_settable(L, -3); lua_pushstring(L, "index"); lua_pushinteger(L, glyph_info[j].cluster); lua_settable(L, -3); double height = extents.y_bearing * point_size / upem; double tHeight = extents.height * point_size / upem; double width = glyph_pos[j].x_advance * point_size / upem; /* The PDF model expects us to make positioning adjustments after a glyph is painted. For this we need to know the natural glyph advance. libtexpdf will use this to compute the adjustment. */ double glyphAdvance = hb_font_get_glyph_h_advance(hbFont, glyph_info[j].codepoint) * point_size / upem; if (direction == HB_DIRECTION_TTB) { height = -glyph_pos[j].y_advance * point_size / upem; tHeight = -height; /* Set depth to 0 - depth has no meaning for TTB */ width = glyphAdvance; glyphAdvance = height; } lua_pushstring(L, "glyphAdvance"); lua_pushnumber(L, glyphAdvance); lua_settable(L, -3); lua_pushstring(L, "width"); lua_pushnumber(L, width); lua_settable(L, -3); lua_pushstring(L, "height"); lua_pushnumber(L, height); lua_settable(L, -3); lua_pushstring(L, "depth"); lua_pushnumber(L, -tHeight - height); lua_settable(L, -3); } /* Cleanup */ hb_buffer_destroy(buf); hb_font_destroy(hbFont); hb_shape_plan_destroy(shape_plan); free(features); return glyph_count; }
static void * create_font_inert (void) { return hb_font_create (hb_face_get_empty ()); }