/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- * 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/. */ #include "gfxGraphiteShaper.h" #include "nsString.h" #include "gfxContext.h" #include "gfxFontConstants.h" #include "gfxTextRun.h" #include "graphite2/Font.h" #include "graphite2/Segment.h" #include "harfbuzz/hb.h" #define FloatToFixed(f) (65536 * (f)) #define FixedToFloat(f) ((f) * (1.0 / 65536.0)) // Right shifts of negative (signed) integers are undefined, as are overflows // when converting unsigned to negative signed integers. // (If speed were an issue we could make some 2's complement assumptions.) #define FixedToIntRound(f) ((f) > 0 ? ((32768 + (f)) >> 16) \ : -((32767 - (f)) >> 16)) using namespace mozilla; // for AutoSwap_* types /* * Creation and destruction; on deletion, release any font tables we're holding */ gfxGraphiteShaper::gfxGraphiteShaper(gfxFont *aFont) : gfxFontShaper(aFont), mGrFace(mFont->GetFontEntry()->GetGrFace()), mGrFont(nullptr), mFallbackToSmallCaps(false) { mCallbackData.mFont = aFont; } gfxGraphiteShaper::~gfxGraphiteShaper() { if (mGrFont) { gr_font_destroy(mGrFont); } mFont->GetFontEntry()->ReleaseGrFace(mGrFace); } /*static*/ float gfxGraphiteShaper::GrGetAdvance(const void* appFontHandle, uint16_t glyphid) { const CallbackData *cb = static_cast<const CallbackData*>(appFontHandle); return FixedToFloat(cb->mFont->GetGlyphWidth(*cb->mDrawTarget, glyphid)); } static inline uint32_t MakeGraphiteLangTag(uint32_t aTag) { uint32_t grLangTag = aTag; // replace trailing space-padding with NULs for graphite uint32_t mask = 0x000000FF; while ((grLangTag & mask) == ' ') { grLangTag &= ~mask; mask <<= 8; } return grLangTag; } struct GrFontFeatures { gr_face *mFace; gr_feature_val *mFeatures; }; static void AddFeature(const uint32_t& aTag, uint32_t& aValue, void *aUserArg) { GrFontFeatures *f = static_cast<GrFontFeatures*>(aUserArg); const gr_feature_ref* fref = gr_face_find_fref(f->mFace, aTag); if (fref) { gr_fref_set_feature_value(fref, aValue, f->mFeatures); } } bool gfxGraphiteShaper::ShapeText(DrawTarget *aDrawTarget, const char16_t *aText, uint32_t aOffset, uint32_t aLength, Script aScript, bool aVertical, gfxShapedText *aShapedText) { // some font back-ends require this in order to get proper hinted metrics if (!mFont->SetupCairoFont(aDrawTarget)) { return false; } mCallbackData.mDrawTarget = aDrawTarget; const gfxFontStyle *style = mFont->GetStyle(); if (!mGrFont) { if (!mGrFace) { return false; } if (mFont->ProvidesGlyphWidths()) { gr_font_ops ops = { sizeof(gr_font_ops), &GrGetAdvance, nullptr // vertical text not yet implemented }; mGrFont = gr_make_font_with_ops(mFont->GetAdjustedSize(), &mCallbackData, &ops, mGrFace); } else { mGrFont = gr_make_font(mFont->GetAdjustedSize(), mGrFace); } if (!mGrFont) { return false; } // determine whether petite-caps falls back to small-caps if (style->variantCaps != NS_FONT_VARIANT_CAPS_NORMAL) { switch (style->variantCaps) { case NS_FONT_VARIANT_CAPS_ALLPETITE: case NS_FONT_VARIANT_CAPS_PETITECAPS: bool synLower, synUpper; mFont->SupportsVariantCaps(aScript, style->variantCaps, mFallbackToSmallCaps, synLower, synUpper); break; default: break; } } } gfxFontEntry *entry = mFont->GetFontEntry(); uint32_t grLang = 0; if (style->languageOverride) { grLang = MakeGraphiteLangTag(style->languageOverride); } else if (entry->mLanguageOverride) { grLang = MakeGraphiteLangTag(entry->mLanguageOverride); } else if (style->explicitLanguage) { nsAutoCString langString; style->language->ToUTF8String(langString); grLang = GetGraphiteTagForLang(langString); } gr_feature_val *grFeatures = gr_face_featureval_for_lang(mGrFace, grLang); // insert any merged features into Graphite feature list GrFontFeatures f = {mGrFace, grFeatures}; MergeFontFeatures(style, mFont->GetFontEntry()->mFeatureSettings, aShapedText->DisableLigatures(), mFont->GetFontEntry()->FamilyName(), mFallbackToSmallCaps, AddFeature, &f); // Graphite shaping doesn't map U+00a0 (nbsp) to space if it is missing // from the font, so check for that possibility. (Most fonts double-map // the space glyph to both 0x20 and 0xA0, so this won't often be needed; // so we don't copy the text until we know it's required.) nsAutoString transformed; const char16_t NO_BREAK_SPACE = 0x00a0; if (!entry->HasCharacter(NO_BREAK_SPACE)) { nsDependentSubstring src(aText, aLength); if (src.FindChar(NO_BREAK_SPACE) != kNotFound) { transformed = src; transformed.ReplaceChar(NO_BREAK_SPACE, ' '); aText = transformed.BeginReading(); } } size_t numChars = gr_count_unicode_characters(gr_utf16, aText, aText + aLength, nullptr); gr_bidirtl grBidi = gr_bidirtl(aShapedText->IsRightToLeft() ? (gr_rtl | gr_nobidi) : gr_nobidi); gr_segment *seg = gr_make_seg(mGrFont, mGrFace, 0, grFeatures, gr_utf16, aText, numChars, grBidi); gr_featureval_destroy(grFeatures); if (!seg) { return false; } nsresult rv = SetGlyphsFromSegment(aDrawTarget, aShapedText, aOffset, aLength, aText, seg); gr_seg_destroy(seg); return NS_SUCCEEDED(rv); } #define SMALL_GLYPH_RUN 256 // avoid heap allocation of per-glyph data arrays // for short (typical) runs up to this length struct Cluster { uint32_t baseChar; // in UTF16 code units, not Unicode character indices uint32_t baseGlyph; uint32_t nChars; // UTF16 code units uint32_t nGlyphs; Cluster() : baseChar(0), baseGlyph(0), nChars(0), nGlyphs(0) { } }; nsresult gfxGraphiteShaper::SetGlyphsFromSegment(DrawTarget *aDrawTarget, gfxShapedText *aShapedText, uint32_t aOffset, uint32_t aLength, const char16_t *aText, gr_segment *aSegment) { int32_t dev2appUnits = aShapedText->GetAppUnitsPerDevUnit(); bool rtl = aShapedText->IsRightToLeft(); uint32_t glyphCount = gr_seg_n_slots(aSegment); // identify clusters; graphite may have reordered/expanded/ligated glyphs. AutoTArray<Cluster,SMALL_GLYPH_RUN> clusters; AutoTArray<uint16_t,SMALL_GLYPH_RUN> gids; AutoTArray<float,SMALL_GLYPH_RUN> xLocs; AutoTArray<float,SMALL_GLYPH_RUN> yLocs; if (!clusters.SetLength(aLength, fallible) || !gids.SetLength(glyphCount, fallible) || !xLocs.SetLength(glyphCount, fallible) || !yLocs.SetLength(glyphCount, fallible)) { return NS_ERROR_OUT_OF_MEMORY; } // walk through the glyph slots and check which original character // each is associated with uint32_t gIndex = 0; // glyph slot index uint32_t cIndex = 0; // current cluster index for (const gr_slot *slot = gr_seg_first_slot(aSegment); slot != nullptr; slot = gr_slot_next_in_segment(slot), gIndex++) { uint32_t before = gr_cinfo_base(gr_seg_cinfo(aSegment, gr_slot_before(slot))); uint32_t after = gr_cinfo_base(gr_seg_cinfo(aSegment, gr_slot_after(slot))); gids[gIndex] = gr_slot_gid(slot); xLocs[gIndex] = gr_slot_origin_X(slot); yLocs[gIndex] = gr_slot_origin_Y(slot); // if this glyph has a "before" character index that precedes the // current cluster's char index, we need to merge preceding // clusters until it gets included while (before < clusters[cIndex].baseChar && cIndex > 0) { clusters[cIndex-1].nChars += clusters[cIndex].nChars; clusters[cIndex-1].nGlyphs += clusters[cIndex].nGlyphs; --cIndex; } // if there's a gap between the current cluster's base character and // this glyph's, extend the cluster to include the intervening chars if (gr_slot_can_insert_before(slot) && clusters[cIndex].nChars && before >= clusters[cIndex].baseChar + clusters[cIndex].nChars) { NS_ASSERTION(cIndex < aLength - 1, "cIndex at end of word"); Cluster& c = clusters[cIndex + 1]; c.baseChar = clusters[cIndex].baseChar + clusters[cIndex].nChars; c.nChars = before - c.baseChar; c.baseGlyph = gIndex; c.nGlyphs = 0; ++cIndex; } // increment cluster's glyph count to include current slot NS_ASSERTION(cIndex < aLength, "cIndex beyond word length"); ++clusters[cIndex].nGlyphs; // bump |after| index if it falls in the middle of a surrogate pair if (NS_IS_HIGH_SURROGATE(aText[after]) && after < aLength - 1 && NS_IS_LOW_SURROGATE(aText[after + 1])) { after++; } // extend cluster if necessary to reach the glyph's "after" index if (clusters[cIndex].baseChar + clusters[cIndex].nChars < after + 1) { clusters[cIndex].nChars = after + 1 - clusters[cIndex].baseChar; } } bool roundX, roundY; GetRoundOffsetsToPixels(aDrawTarget, &roundX, &roundY); gfxShapedText::CompressedGlyph *charGlyphs = aShapedText->GetCharacterGlyphs() + aOffset; // now put glyphs into the textrun, one cluster at a time for (uint32_t i = 0; i <= cIndex; ++i) { const Cluster& c = clusters[i]; float adv; // total advance of the cluster if (rtl) { if (i == 0) { adv = gr_seg_advance_X(aSegment) - xLocs[c.baseGlyph]; } else { adv = xLocs[clusters[i-1].baseGlyph] - xLocs[c.baseGlyph]; } } else { if (i == cIndex) { adv = gr_seg_advance_X(aSegment) - xLocs[c.baseGlyph]; } else { adv = xLocs[clusters[i+1].baseGlyph] - xLocs[c.baseGlyph]; } } // Check for default-ignorable char that didn't get filtered, combined, // etc by the shaping process, and skip it. uint32_t offs = c.baseChar; NS_ASSERTION(offs < aLength, "unexpected offset"); if (c.nGlyphs == 1 && c.nChars == 1 && aShapedText->FilterIfIgnorable(aOffset + offs, aText[offs])) { continue; } uint32_t appAdvance = roundX ? NSToIntRound(adv) * dev2appUnits : NSToIntRound(adv * dev2appUnits); if (c.nGlyphs == 1 && gfxShapedText::CompressedGlyph::IsSimpleGlyphID(gids[c.baseGlyph]) && gfxShapedText::CompressedGlyph::IsSimpleAdvance(appAdvance) && charGlyphs[offs].IsClusterStart() && yLocs[c.baseGlyph] == 0) { charGlyphs[offs].SetSimpleGlyph(appAdvance, gids[c.baseGlyph]); } else { // not a one-to-one mapping with simple metrics: use DetailedGlyph AutoTArray<gfxShapedText::DetailedGlyph,8> details; float clusterLoc; for (uint32_t j = c.baseGlyph; j < c.baseGlyph + c.nGlyphs; ++j) { gfxShapedText::DetailedGlyph* d = details.AppendElement(); d->mGlyphID = gids[j]; d->mYOffset = roundY ? NSToIntRound(-yLocs[j]) * dev2appUnits : -yLocs[j] * dev2appUnits; if (j == c.baseGlyph) { d->mXOffset = 0; d->mAdvance = appAdvance; clusterLoc = xLocs[j]; } else { float dx = rtl ? (xLocs[j] - clusterLoc) : (xLocs[j] - clusterLoc - adv); d->mXOffset = roundX ? NSToIntRound(dx) * dev2appUnits : dx * dev2appUnits; d->mAdvance = 0; } } gfxShapedText::CompressedGlyph g; g.SetComplex(charGlyphs[offs].IsClusterStart(), true, details.Length()); aShapedText->SetGlyphs(aOffset + offs, g, details.Elements()); } for (uint32_t j = c.baseChar + 1; j < c.baseChar + c.nChars; ++j) { NS_ASSERTION(j < aLength, "unexpected offset"); gfxShapedText::CompressedGlyph &g = charGlyphs[j]; NS_ASSERTION(!g.IsSimpleGlyph(), "overwriting a simple glyph"); g.SetComplex(g.IsClusterStart(), false, 0); } } return NS_OK; } #undef SMALL_GLYPH_RUN // for language tag validation - include list of tags from the IANA registry #include "gfxLanguageTagList.cpp" nsTHashtable<nsUint32HashKey> *gfxGraphiteShaper::sLanguageTags; /*static*/ uint32_t gfxGraphiteShaper::GetGraphiteTagForLang(const nsCString& aLang) { int len = aLang.Length(); if (len < 2) { return 0; } // convert primary language subtag to a left-packed, NUL-padded integer // for the Graphite API uint32_t grLang = 0; for (int i = 0; i < 4; ++i) { grLang <<= 8; if (i < len) { uint8_t ch = aLang[i]; if (ch == '-') { // found end of primary language subtag, truncate here len = i; continue; } if (ch < 'a' || ch > 'z') { // invalid character in tag, so ignore it completely return 0; } grLang += ch; } } // valid tags must have length = 2 or 3 if (len < 2 || len > 3) { return 0; } if (!sLanguageTags) { // store the registered IANA tags in a hash for convenient validation sLanguageTags = new nsTHashtable<nsUint32HashKey>(ArrayLength(sLanguageTagList)); for (const uint32_t *tag = sLanguageTagList; *tag != 0; ++tag) { sLanguageTags->PutEntry(*tag); } } // only accept tags known in the IANA registry if (sLanguageTags->GetEntry(grLang)) { return grLang; } return 0; } /*static*/ void gfxGraphiteShaper::Shutdown() { #ifdef NS_FREE_PERMANENT_DATA if (sLanguageTags) { sLanguageTags->Clear(); delete sLanguageTags; sLanguageTags = nullptr; } #endif }