The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 20; 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 "gfxFT2FontBase.h"

 #include "gfxFT2Utils.h"

 #include "harfbuzz/hb.h"

 #include "mozilla/Likely.h"

 #include "gfxFontConstants.h"

 #include "gfxFontUtils.h"

 using namespace mozilla::gfx;

 gfxFT2FontBase::gfxFT2FontBase(cairo_scaled_font_t *aScaledFont,

                                gfxFontEntry *aFontEntry,

                                const gfxFontStyle *aFontStyle)

     : gfxFont(aFontEntry, aFontStyle, kAntialiasDefault, aScaledFont),

       mSpaceGlyph(0),

       mHasMetrics(false)

 {

     cairo_scaled_font_reference(mScaledFont);

     ConstructFontOptions();

 }

 gfxFT2FontBase::~gfxFT2FontBase()

 {

     cairo_scaled_font_destroy(mScaledFont);

 }

 uint32_t

 gfxFT2FontBase::GetGlyph(uint32_t aCharCode)

 {

     // FcFreeTypeCharIndex needs to lock the FT_Face and can end up searching

     // through all the postscript glyph names in the font.  Therefore use a

     // lightweight cache, which is stored on the cairo_font_face_t.

     cairo_font_face_t *face =

         cairo_scaled_font_get_font_face(CairoScaledFont());

     if (cairo_font_face_status(face) != CAIRO_STATUS_SUCCESS)

         return 0;

     // This cache algorithm and size is based on what is done in

     // cairo_scaled_font_text_to_glyphs and pango_fc_font_real_get_glyph.  I

     // think the concept is that adjacent characters probably come mostly from

     // one Unicode block.  This assumption is probably not so valid with

     // scripts with large character sets as used for East Asian languages.

     struct CmapCacheSlot {

         uint32_t mCharCode;

         uint32_t mGlyphIndex;

     };

     const uint32_t kNumSlots = 256;

     static cairo_user_data_key_t sCmapCacheKey;

     CmapCacheSlot *slots = static_cast<CmapCacheSlot*>

         (cairo_font_face_get_user_data(face, &sCmapCacheKey));

     if (!slots) {

         // cairo's caches can keep some cairo_font_faces alive past our last

         // destroy, so the destroy function (free) for the cache must be

         // callable from cairo without any assumptions about what other

         // modules have not been shutdown.

         slots = static_cast<CmapCacheSlot*>

             (calloc(kNumSlots, sizeof(CmapCacheSlot)));

         if (!slots)

             return 0;

         cairo_status_t status =

             cairo_font_face_set_user_data(face, &sCmapCacheKey, slots, free);

         if (status != CAIRO_STATUS_SUCCESS) { // OOM

             free(slots);

             return 0;

         }

         // Invalidate slot 0 by setting its char code to something that would

         // never end up in slot 0.  All other slots are already invalid

         // because they have mCharCode = 0 and a glyph for char code 0 will

         // always be in the slot 0.

         slots[0].mCharCode = 1;

     }

     CmapCacheSlot *slot = &slots[aCharCode % kNumSlots];

     if (slot->mCharCode != aCharCode) {

         slot->mCharCode = aCharCode;

         slot->mGlyphIndex = gfxFT2LockedFace(this).GetGlyph(aCharCode);

     }

     return slot->mGlyphIndex;

 }

 void

 gfxFT2FontBase::GetGlyphExtents(uint32_t aGlyph, cairo_text_extents_t* aExtents)

 {

     NS_PRECONDITION(aExtents != nullptr, "aExtents must not be NULL");

     cairo_glyph_t glyphs[1];

     glyphs[0].index = aGlyph;

     glyphs[0].x = 0.0;

     glyphs[0].y = 0.0;

     // cairo does some caching for us here but perhaps a small gain could be

     // made by caching more.  It is usually only the advance that is needed,

     // so caching only the advance could allow many requests to be cached with

     // little memory use.  Ideally this cache would be merged with

     // gfxGlyphExtents.

     cairo_scaled_font_glyph_extents(CairoScaledFont(), glyphs, 1, aExtents);

 }

 const gfxFont::Metrics&

 gfxFT2FontBase::GetMetrics()

 {

     if (mHasMetrics)

         return mMetrics;

     if (MOZ_UNLIKELY(GetStyle()->size <= 0.0)) {

         new(&mMetrics) gfxFont::Metrics(); // zero initialize

         mSpaceGlyph = 0;

     } else {

         gfxFT2LockedFace face(this);

         mFUnitsConvFactor = face.XScale();

         face.GetMetrics(&mMetrics, &mSpaceGlyph);

     }

     SanitizeMetrics(&mMetrics, false);

 #if 0

     //    printf("font name: %s %f\n", NS_ConvertUTF16toUTF8(GetName()).get(), GetStyle()->size);

     //    printf ("pango font %s\n", pango_font_description_to_string (pango_font_describe (font)));

     fprintf (stderr, "Font: %s\n", NS_ConvertUTF16toUTF8(GetName()).get());

     fprintf (stderr, "    emHeight: %f emAscent: %f emDescent: %f\n", mMetrics.emHeight, mMetrics.emAscent, mMetrics.emDescent);

     fprintf (stderr, "    maxAscent: %f maxDescent: %f\n", mMetrics.maxAscent, mMetrics.maxDescent);

     fprintf (stderr, "    internalLeading: %f externalLeading: %f\n", mMetrics.externalLeading, mMetrics.internalLeading);

     fprintf (stderr, "    spaceWidth: %f aveCharWidth: %f xHeight: %f\n", mMetrics.spaceWidth, mMetrics.aveCharWidth, mMetrics.xHeight);

     fprintf (stderr, "    uOff: %f uSize: %f stOff: %f stSize: %f suOff: %f suSize: %f\n", mMetrics.underlineOffset, mMetrics.underlineSize, mMetrics.strikeoutOffset, mMetrics.strikeoutSize, mMetrics.superscriptOffset, mMetrics.subscriptOffset);

 #endif

     mHasMetrics = true;

     return mMetrics;

 }

 // Get the glyphID of a space

 uint32_t

 gfxFT2FontBase::GetSpaceGlyph()

 {

     NS_ASSERTION(GetStyle()->size != 0,

                  "forgot to short-circuit a text run with zero-sized font?");

     GetMetrics();

     return mSpaceGlyph;

 }

 uint32_t

 gfxFT2FontBase::GetGlyph(uint32_t unicode, uint32_t variation_selector)

 {

     if (variation_selector) {

         uint32_t id =

             gfxFT2LockedFace(this).GetUVSGlyph(unicode, variation_selector);

         if (id)

             return id;

         id = gfxFontUtils::GetUVSFallback(unicode, variation_selector);

         if (id) {

             unicode = id;

         }

     }

     return GetGlyph(unicode);

 }

 int32_t

 gfxFT2FontBase::GetGlyphWidth(gfxContext *aCtx, uint16_t aGID)

 {

     cairo_text_extents_t extents;

     GetGlyphExtents(aGID, &extents);

     // convert to 16.16 fixed point

     return NS_lround(0x10000 * extents.x_advance);

 }

 bool

 gfxFT2FontBase::SetupCairoFont(gfxContext *aContext)

 {

     cairo_t *cr = aContext->GetCairo();

     // The scaled font ctm is not relevant right here because

     // cairo_set_scaled_font does not record the scaled font itself, but

     // merely the font_face, font_matrix, font_options.  The scaled_font used

     // for the target can be different from the scaled_font passed to

     // cairo_set_scaled_font.  (Unfortunately we have measured only for an

     // identity ctm.)

     cairo_scaled_font_t *cairoFont = CairoScaledFont();

     if (cairo_scaled_font_status(cairoFont) != CAIRO_STATUS_SUCCESS) {

         // Don't cairo_set_scaled_font as that would propagate the error to

         // the cairo_t, precluding any further drawing.

         return false;

     }

     // Thoughts on which font_options to set on the context:

     //

     // cairoFont has been created for screen rendering.

     //

     // When the context is being used for screen rendering, we should set

     // font_options such that the same scaled_font gets used (when the ctm is

     // the same).  The use of explicit font_options recorded in

     // CreateScaledFont ensures that this will happen.

     //

     // XXXkt: For pdf and ps surfaces, I don't know whether it's better to

     // remove surface-specific options, or try to draw with the same

     // scaled_font that was used to measure.  As the same font_face is being

     // used, its font_options will often override some values anyway (unless

     // perhaps we remove those from the FcPattern at face creation).

     //

     // I can't see any significant difference in printing, irrespective of

     // what is set here.  It's too late to change things here as measuring has

     // already taken place.  We should really be measuring with a different

     // font for pdf and ps surfaces (bug 403513).

     cairo_set_scaled_font(cr, cairoFont);

     return true;

 }

 void

 gfxFT2FontBase::ConstructFontOptions()

 {

   NS_LossyConvertUTF16toASCII name(this->GetName());

   mFontOptions.mName = name.get();

   const gfxFontStyle* style = this->GetStyle();

   if (style->style == NS_FONT_STYLE_ITALIC) {

     if (style->weight == NS_FONT_WEIGHT_BOLD) {

       mFontOptions.mStyle = FontStyle::BOLD_ITALIC;

     } else {

       mFontOptions.mStyle = FontStyle::ITALIC;

     }

   } else {

     if (style->weight == NS_FONT_WEIGHT_BOLD) {

       mFontOptions.mStyle = FontStyle::BOLD;

     } else {

       mFontOptions.mStyle = FontStyle::NORMAL;

     }

   }

 }