/* -*- 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"

#include <algorithm>

#include <dlfcn.h>

#include FT_TRUETYPE_TAGS_H

#include FT_TRUETYPE_TABLES_H

#include FT_ADVANCES_H

#include FT_MULTIPLE_MASTERS_H

#ifndef FT_FACE_FLAG_COLOR

#define FT_FACE_FLAG_COLOR ( 1L << 14 )

#endif

using namespace mozilla::gfx;

gfxFT2FontBase::gfxFT2FontBase(const RefPtr<UnscaledFontFreeType>& aUnscaledFont,

                               cairo_scaled_font_t *aScaledFont,

                               gfxFontEntry *aFontEntry,

                               const gfxFontStyle *aFontStyle)

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

    , mSpaceGlyph(0)

{

    mEmbolden = aFontStyle->NeedsSyntheticBold(aFontEntry);

    cairo_scaled_font_reference(mScaledFont);

    InitMetrics();

}

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(GetCairoScaledFont());

    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)

{

    MOZ_ASSERT(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(GetCairoScaledFont(), glyphs, 1, aExtents);

}

// aScale is intended for a 16.16 x/y_scale of an FT_Size_Metrics

static inline FT_Long

ScaleRoundDesignUnits(FT_Short aDesignMetric, FT_Fixed aScale)

{

    FT_Long fixed26dot6 = FT_MulFix(aDesignMetric, aScale);

    return ROUND_26_6_TO_INT(fixed26dot6);

}

// Snap a line to pixels while keeping the center and size of the line as

// close to the original position as possible.

//

// Pango does similar snapping for underline and strikethrough when fonts are

// hinted, but nsCSSRendering::GetTextDecorationRectInternal always snaps the

// top and size of lines.  Optimizing the distance between the line and

// baseline is probably good for the gap between text and underline, but

// optimizing the center of the line is better for positioning strikethough.

static void

SnapLineToPixels(gfxFloat& aOffset, gfxFloat& aSize)

{

    gfxFloat snappedSize = std::max(floor(aSize + 0.5), 1.0);

    // Correct offset for change in size

    gfxFloat offset = aOffset - 0.5 * (aSize - snappedSize);

    // Snap offset

    aOffset = floor(offset + 0.5);

    aSize = snappedSize;

}

/**

 * Get extents for a simple character representable by a single glyph.

 * The return value is the glyph id of that glyph or zero if no such glyph

 * exists.  aExtents is only set when this returns a non-zero glyph id.

 */

uint32_t

gfxFT2FontBase::GetCharExtents(char aChar, cairo_text_extents_t* aExtents)

{

    FT_UInt gid = GetGlyph(aChar);

    if (gid) {

        GetGlyphExtents(gid, aExtents);

    }

    return gid;

}

/**

 * Get glyph id and width for a simple character.

 * The return value is the glyph id of that glyph or zero if no such glyph

 * exists.  aWidth is only set when this returns a non-zero glyph id.

 * This is just for use during initialization, and doesn't use the width cache.

 */

uint32_t

gfxFT2FontBase::GetCharWidth(char aChar, gfxFloat* aWidth)

{

    FT_UInt gid = GetGlyph(aChar);

    if (gid) {

        int32_t width;

        if (!GetFTGlyphAdvance(gid, &width)) {

            cairo_text_extents_t extents;

            GetGlyphExtents(gid, &extents);

            width = NS_lround(0x10000 * extents.x_advance);

        }

        *aWidth = FLOAT_FROM_16_16(width);

    }

    return gid;

}

void

gfxFT2FontBase::InitMetrics()

{

    mFUnitsConvFactor = 0.0;

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

        MOZ_UNLIKELY(GetStyle()->sizeAdjust == 0.0)) {

        memset(&mMetrics, 0, sizeof(mMetrics)); // zero initialize

        mSpaceGlyph = GetGlyph(' ');

        return;

    }

    // Explicitly lock the face so we can release it early before calling

    // back into Cairo below.

    FT_Face face = cairo_ft_scaled_font_lock_face(GetCairoScaledFont());

    if (MOZ_UNLIKELY(!face)) {

        // No face.  This unfortunate situation might happen if the font

        // file is (re)moved at the wrong time.

        const gfxFloat emHeight = GetAdjustedSize();

        mMetrics.emHeight = emHeight;

        mMetrics.maxAscent = mMetrics.emAscent = 0.8 * emHeight;

        mMetrics.maxDescent = mMetrics.emDescent = 0.2 * emHeight;

        mMetrics.maxHeight = emHeight;

        mMetrics.internalLeading = 0.0;

        mMetrics.externalLeading = 0.2 * emHeight;

        const gfxFloat spaceWidth = 0.5 * emHeight;

        mMetrics.spaceWidth = spaceWidth;

        mMetrics.maxAdvance = spaceWidth;

        mMetrics.aveCharWidth = spaceWidth;

        mMetrics.zeroOrAveCharWidth = spaceWidth;

        const gfxFloat xHeight = 0.5 * emHeight;

        mMetrics.xHeight = xHeight;

        mMetrics.capHeight = mMetrics.maxAscent;

        const gfxFloat underlineSize = emHeight / 14.0;

        mMetrics.underlineSize = underlineSize;

        mMetrics.underlineOffset = -underlineSize;

        mMetrics.strikeoutOffset = 0.25 * emHeight;

        mMetrics.strikeoutSize = underlineSize;

        SanitizeMetrics(&mMetrics, false);

        return;

    }

    if (face->face_flags & FT_FACE_FLAG_MULTIPLE_MASTERS) {

        // Resolve variations from entry (descriptor) and style (property)

        AutoTArray<gfxFontVariation,8> settings;

        mFontEntry->GetVariationsForStyle(settings, mStyle);

        SetupVarCoords(mFontEntry->GetMMVar(), settings, &mCoords);

        if (!mCoords.IsEmpty()) {

#if MOZ_TREE_FREETYPE

            FT_Set_Var_Design_Coordinates(face, mCoords.Length(), mCoords.Elements());

#else

            typedef FT_Error (*SetCoordsFunc)(FT_Face, FT_UInt, FT_Fixed*);

            static SetCoordsFunc setCoords;

            static bool firstTime = true;

            if (firstTime) {

                firstTime = false;

                setCoords = (SetCoordsFunc)

                    dlsym(RTLD_DEFAULT, "FT_Set_Var_Design_Coordinates");

            }

            if (setCoords) {

                (*setCoords)(face, mCoords.Length(), mCoords.Elements());

            }

#endif

        }

    }

    const FT_Size_Metrics& ftMetrics = face->size->metrics;

    mMetrics.maxAscent = FLOAT_FROM_26_6(ftMetrics.ascender);

    mMetrics.maxDescent = -FLOAT_FROM_26_6(ftMetrics.descender);

    mMetrics.maxAdvance = FLOAT_FROM_26_6(ftMetrics.max_advance);

    gfxFloat lineHeight = FLOAT_FROM_26_6(ftMetrics.height);

    gfxFloat emHeight;

    // Scale for vertical design metric conversion: pixels per design unit.

    // If this remains at 0.0, we can't use metrics from OS/2 etc.

    gfxFloat yScale = 0.0;

    if (FT_IS_SCALABLE(face)) {

        // Prefer FT_Size_Metrics::x_scale to x_ppem as x_ppem does not

        // have subpixel accuracy.

        //

        // FT_Size_Metrics::y_scale is in 16.16 fixed point format.  Its

        // (fractional) value is a factor that converts vertical metrics from

        // design units to units of 1/64 pixels, so that the result may be

        // interpreted as pixels in 26.6 fixed point format.

        mFUnitsConvFactor = FLOAT_FROM_26_6(FLOAT_FROM_16_16(ftMetrics.x_scale));

        yScale = FLOAT_FROM_26_6(FLOAT_FROM_16_16(ftMetrics.y_scale));

        emHeight = face->units_per_EM * yScale;

    } else { // Not scalable.

        emHeight = ftMetrics.y_ppem;

        // FT_Face doc says units_per_EM and a bunch of following fields

        // are "only relevant to scalable outlines". If it's an sfnt,

        // we can get units_per_EM from the 'head' table instead; otherwise,

        // we don't have a unitsPerEm value so we can't compute/use yScale or

        // mFUnitsConvFactor (x scale).

        const TT_Header* head =

            static_cast<TT_Header*>(FT_Get_Sfnt_Table(face, ft_sfnt_head));

        if (head) {

            // Bug 1267909 - Even if the font is not explicitly scalable,

            // if the face has color bitmaps, it should be treated as scalable

            // and scaled to the desired size. Metrics based on y_ppem need

            // to be rescaled for the adjusted size. This makes metrics agree

            // with the scales we pass to Cairo for Fontconfig fonts.

            if (face->face_flags & FT_FACE_FLAG_COLOR) {

                emHeight = GetAdjustedSize();

                gfxFloat adjustScale = emHeight / ftMetrics.y_ppem;

                mMetrics.maxAscent *= adjustScale;

                mMetrics.maxDescent *= adjustScale;

                mMetrics.maxAdvance *= adjustScale;

                lineHeight *= adjustScale;

            }

            gfxFloat emUnit = head->Units_Per_EM;

            mFUnitsConvFactor = ftMetrics.x_ppem / emUnit;

            yScale = emHeight / emUnit;

        }

    }

    TT_OS2 *os2 =

        static_cast<TT_OS2*>(FT_Get_Sfnt_Table(face, ft_sfnt_os2));

    if (os2 && os2->sTypoAscender && yScale > 0.0) {

        mMetrics.emAscent = os2->sTypoAscender * yScale;

        mMetrics.emDescent = -os2->sTypoDescender * yScale;

        FT_Short typoHeight =

            os2->sTypoAscender - os2->sTypoDescender + os2->sTypoLineGap;

        lineHeight = typoHeight * yScale;

        // If the OS/2 fsSelection USE_TYPO_METRICS bit is set,

        // set maxAscent/Descent from the sTypo* fields instead of hhea.

        const uint16_t kUseTypoMetricsMask = 1 << 7;

        if ((os2->fsSelection & kUseTypoMetricsMask) ||

            // maxAscent/maxDescent get used for frame heights, and some fonts

            // don't have the HHEA table ascent/descent set (bug 279032).

      (mMetrics.maxAscent == 0.0 && mMetrics.maxDescent == 0.0)) {

            // We use NS_round here to parallel the pixel-rounded values that

            // freetype gives us for ftMetrics.ascender/descender.

            mMetrics.maxAscent = NS_round(mMetrics.emAscent);

            mMetrics.maxDescent = NS_round(mMetrics.emDescent);

        }

    } else {

        mMetrics.emAscent = mMetrics.maxAscent;

        mMetrics.emDescent = mMetrics.maxDescent;

    }

    // gfxFont::Metrics::underlineOffset is the position of the top of the

    // underline.

    //

    // FT_FaceRec documentation describes underline_position as "the

    // center of the underlining stem".  This was the original definition

    // of the PostScript metric, but in the PostScript table of OpenType

    // fonts the metric is "the top of the underline"

    // (http://www.microsoft.com/typography/otspec/post.htm), and FreeType

    // (up to version 2.3.7) doesn't make any adjustment.

    //

    // Therefore get the underline position directly from the table

    // ourselves when this table exists.  Use FreeType's metrics for

    // other (including older PostScript) fonts.

    if (face->underline_position && face->underline_thickness && yScale > 0.0) {

        mMetrics.underlineSize = face->underline_thickness * yScale;

        TT_Postscript *post = static_cast<TT_Postscript*>

            (FT_Get_Sfnt_Table(face, ft_sfnt_post));

        if (post && post->underlinePosition) {

            mMetrics.underlineOffset = post->underlinePosition * yScale;

        } else {

            mMetrics.underlineOffset = face->underline_position * yScale

                + 0.5 * mMetrics.underlineSize;

        }

    } else { // No underline info.

        // Imitate Pango.

        mMetrics.underlineSize = emHeight / 14.0;

        mMetrics.underlineOffset = -mMetrics.underlineSize;

    }

    if (os2 && os2->yStrikeoutSize && os2->yStrikeoutPosition && yScale > 0.0) {

        mMetrics.strikeoutSize = os2->yStrikeoutSize * yScale;

        mMetrics.strikeoutOffset = os2->yStrikeoutPosition * yScale;

    } else { // No strikeout info.

        mMetrics.strikeoutSize = mMetrics.underlineSize;

        // Use OpenType spec's suggested position for Roman font.

        mMetrics.strikeoutOffset = emHeight * 409.0 / 2048.0

            + 0.5 * mMetrics.strikeoutSize;

    }

    SnapLineToPixels(mMetrics.strikeoutOffset, mMetrics.strikeoutSize);

    if (os2 && os2->sxHeight && yScale > 0.0) {

        mMetrics.xHeight = os2->sxHeight * yScale;

    } else {

        // CSS 2.1, section 4.3.2 Lengths: "In the cases where it is

        // impossible or impractical to determine the x-height, a value of

        // 0.5em should be used."

        mMetrics.xHeight = 0.5 * emHeight;

    }

    // aveCharWidth is used for the width of text input elements so be

    // liberal rather than conservative in the estimate.

    if (os2 && os2->xAvgCharWidth) {

        // Round to pixels as this is compared with maxAdvance to guess

        // whether this is a fixed width font.

        mMetrics.aveCharWidth =

            ScaleRoundDesignUnits(os2->xAvgCharWidth, ftMetrics.x_scale);

    } else {

        mMetrics.aveCharWidth = 0.0; // updated below

    }

    if (os2 && os2->sCapHeight && yScale > 0.0) {

        mMetrics.capHeight = os2->sCapHeight * yScale;

    } else {

        mMetrics.capHeight = mMetrics.maxAscent;

    }

    // Release the face lock to safely load glyphs with GetCharExtents if

    // necessary without recursively locking.

    cairo_ft_scaled_font_unlock_face(GetCairoScaledFont());

    gfxFloat width;

    mSpaceGlyph = GetCharWidth(' ', &width);

    if (mSpaceGlyph) {

        mMetrics.spaceWidth = width;

    } else {

        mMetrics.spaceWidth = mMetrics.maxAdvance; // guess

    }

    if (GetCharWidth('0', &width)) {

        mMetrics.zeroOrAveCharWidth = width;

    } else {

        mMetrics.zeroOrAveCharWidth = 0.0;

    }

    // Prefering a measured x over sxHeight because sxHeight doesn't consider

    // hinting, but maybe the x extents are not quite right in some fancy

    // script fonts.  CSS 2.1 suggests possibly using the height of an "o",

    // which would have a more consistent glyph across fonts.

    cairo_text_extents_t extents;

    if (GetCharExtents('x', &extents) && extents.y_bearing < 0.0) {

        mMetrics.xHeight = -extents.y_bearing;

        mMetrics.aveCharWidth =

            std::max(mMetrics.aveCharWidth, extents.x_advance);

    }

    if (GetCharExtents('H', &extents) && extents.y_bearing < 0.0) {

        mMetrics.capHeight = -extents.y_bearing;

    }

    mMetrics.aveCharWidth =

        std::max(mMetrics.aveCharWidth, mMetrics.zeroOrAveCharWidth);

    if (mMetrics.aveCharWidth == 0.0) {

        mMetrics.aveCharWidth = mMetrics.spaceWidth;

    }

    if (mMetrics.zeroOrAveCharWidth == 0.0) {

        mMetrics.zeroOrAveCharWidth = mMetrics.aveCharWidth;

    }

    // Apparently hinting can mean that max_advance is not always accurate.

    mMetrics.maxAdvance =

        std::max(mMetrics.maxAdvance, mMetrics.aveCharWidth);

    mMetrics.maxHeight = mMetrics.maxAscent + mMetrics.maxDescent;

    // Make the line height an integer number of pixels so that lines will be

    // equally spaced (rather than just being snapped to pixels, some up and

    // some down).  Layout calculates line height from the emHeight +

    // internalLeading + externalLeading, but first each of these is rounded

    // to layout units.  To ensure that the result is an integer number of

    // pixels, round each of the components to pixels.

    mMetrics.emHeight = floor(emHeight + 0.5);

    // maxHeight will normally be an integer, but round anyway in case

    // FreeType is configured differently.

    mMetrics.internalLeading =

        floor(mMetrics.maxHeight - mMetrics.emHeight + 0.5);

    // Text input boxes currently don't work well with lineHeight

    // significantly less than maxHeight (with Verdana, for example).

    lineHeight = floor(std::max(lineHeight, mMetrics.maxHeight) + 0.5);

    mMetrics.externalLeading =

        lineHeight - mMetrics.internalLeading - mMetrics.emHeight;

    // Ensure emAscent + emDescent == emHeight

    gfxFloat sum = mMetrics.emAscent + mMetrics.emDescent;

    mMetrics.emAscent = sum > 0.0 ?

        mMetrics.emAscent * mMetrics.emHeight / sum : 0.0;

    mMetrics.emDescent = mMetrics.emHeight - mMetrics.emAscent;

    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\n", mMetrics.underlineOffset, mMetrics.underlineSize, mMetrics.strikeoutOffset, mMetrics.strikeoutSize);

#endif

}

const gfxFont::Metrics&

gfxFT2FontBase::GetHorizontalMetrics()

{

    return mMetrics;

}

// Get the glyphID of a space

uint32_t

gfxFT2FontBase::GetSpaceGlyph()

{

    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;

        }

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

        if (unicode) {

            return GetGlyph(unicode);

        }

        return 0;

    }

    return GetGlyph(unicode);

}

bool

gfxFT2FontBase::GetFTGlyphAdvance(uint16_t aGID, int32_t* aAdvance)

{

    gfxFT2LockedFace face(this);

    MOZ_ASSERT(face.get());

    if (!face.get()) {

        // Failed to get the FT_Face? Give up already.

        NS_WARNING("failed to get FT_Face!");

        return false;

    }

    // Due to bugs like 1435234 and 1440938, we currently prefer to fall back

    // to reading the advance from cairo extents, unless we're dealing with

    // a variation font (for which cairo metrics may be wrong, due to FreeType

    // bug 52683).

    if (!(face.get()->face_flags & FT_FACE_FLAG_SCALABLE) ||

        !(face.get()->face_flags & FT_FACE_FLAG_MULTIPLE_MASTERS)) {

        return false;

    }

    bool hinting = gfxPlatform::GetPlatform()->FontHintingEnabled();

    int32_t flags =

        hinting ? FT_LOAD_ADVANCE_ONLY

                : FT_LOAD_ADVANCE_ONLY | FT_LOAD_NO_AUTOHINT | FT_LOAD_NO_HINTING;

    FT_Error ftError = Factory::LoadFTGlyph(face.get(), aGID, flags);

    if (ftError != FT_Err_Ok) {

        // FT_Face was somehow broken/invalid? Don't try to access glyph slot.

        // This probably shouldn't happen, but does: see bug 1440938.

        NS_WARNING("failed to load glyph!");

        return false;

    }

    // Due to freetype bug 52683 we MUST use the linearHoriAdvance field when

    // dealing with a variation font. (And other fonts would have returned

    // earlier, so only variation fonts currently reach here.)

    FT_Fixed advance = face.get()->glyph->linearHoriAdvance;

    // If freetype emboldening is being used, and it's not a zero-width glyph,

    // adjust the advance to account for the increased width.

    if (mEmbolden && advance > 0) {

        // This is the embolden "strength" used by FT_GlyphSlot_Embolden,

        // converted from 26.6 to 16.16

        FT_Fixed strength = 1024 *

            FT_MulFix(face.get()->units_per_EM,

                      face.get()->size->metrics.y_scale) / 24;

        advance += strength;

    }

    // Round the 16.16 fixed-point value to whole pixels for better consistency

    // with how cairo renders the glyphs.

    *aAdvance = (advance + 0x8000) & 0xffff0000u;

    return true;

}

int32_t

gfxFT2FontBase::GetGlyphWidth(DrawTarget& aDrawTarget, uint16_t aGID)

{

    if (!mGlyphWidths) {

        mGlyphWidths =

            mozilla::MakeUnique<nsDataHashtable<nsUint32HashKey,int32_t>>(128);

    }

    int32_t width;

    if (mGlyphWidths->Get(aGID, &width)) {

        return width;

    }

    if (!GetFTGlyphAdvance(aGID, &width)) {

        cairo_text_extents_t extents;

        GetGlyphExtents(aGID, &extents);

        width = NS_lround(0x10000 * extents.x_advance);

    }

    mGlyphWidths->Put(aGID, width);

    return width;

}

bool

gfxFT2FontBase::SetupCairoFont(DrawTarget* aDrawTarget)

{

    // 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 = GetCairoScaledFont();

    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(gfxFont::RefCairo(aDrawTarget), cairoFont);

    return true;

}

// For variation fonts, figure out the variation coordinates to be applied

// for each axis, in freetype's order (which may not match the order of

// axes in mStyle.variationSettings, so we need to search by axis tag).

/*static*/

void

gfxFT2FontBase::SetupVarCoords(FT_MM_Var* aMMVar,

                               const nsTArray<gfxFontVariation>& aVariations,

                               nsTArray<FT_Fixed>* aCoords)

{

    aCoords->TruncateLength(0);

    if (!aMMVar) {

        return;

    }

    for (unsigned i = 0; i < aMMVar->num_axis; ++i) {

        aCoords->AppendElement(aMMVar->axis[i].def);

        for (const auto& v : aVariations) {

            if (aMMVar->axis[i].tag == v.mTag) {

                FT_Fixed val = v.mValue * 0x10000;

                val = std::min(val, aMMVar->axis[i].maximum);

                val = std::max(val, aMMVar->axis[i].minimum);

                (*aCoords)[i] = val;

                break;

            }

        }

    }

}