SkFontScanner_FreeType Class Reference

#include <SkTypeface_FreeType.h>

Inheritance diagram for SkFontScanner_FreeType:

Public Member Functions
	SkFontScanner_FreeType ()
	~SkFontScanner_FreeType () override
bool	scanFile (SkStreamAsset *stream, int *numFaces) const override
bool	scanFace (SkStreamAsset *stream, int faceIndex, int *numInstances) const override
bool	scanInstance (SkStreamAsset *stream, int faceIndex, int instanceIndex, SkString *name, SkFontStyle *style, bool *isFixedPitch, AxisDefinitions *axes) const override
Public Member Functions inherited from SkFontScanner
virtual	~SkFontScanner ()=default
Public Member Functions inherited from SkNoncopyable
	SkNoncopyable ()=default
	SkNoncopyable (SkNoncopyable &&)=default
SkNoncopyable &	operator= (SkNoncopyable &&)=default

Static Public Member Functions
static void	computeAxisValues (AxisDefinitions axisDefinitions, const SkFontArguments::VariationPosition position, SkFixed *axisValues, const SkString &name, SkFontStyle *style, const SkFontArguments::VariationPosition::Coordinate *currentPosition=nullptr)
static bool	GetAxes (FT_Face face, AxisDefinitions *axes)

Additional Inherited Members
Public Types inherited from SkFontScanner
typedef skia_private::STArray< 4, AxisDefinition, true >	AxisDefinitions

Detailed Description

Definition at line 110 of file SkTypeface_FreeType.h.

Constructor & Destructor Documentation

SkFontScanner_FreeType()

SkFontScanner_FreeType::SkFontScanner_FreeType

(

)

Definition at line 2022 of file SkFontHost_FreeType.cpp.

                                               : fLibrary(nullptr) {
    if (FT_New_Library(&gFTMemory, &fLibrary)) {
        return;
    }
    FT_Add_Default_Modules(fLibrary);
    FT_Set_Default_Properties(fLibrary);
}

~SkFontScanner_FreeType()

SkFontScanner_FreeType::~SkFontScanner_FreeType ( )

override

Definition at line 2030 of file SkFontHost_FreeType.cpp.

                                                {
    if (fLibrary) {
        FT_Done_Library(fLibrary);
    }
}

Member Function Documentation

computeAxisValues()

void SkFontScanner_FreeType::computeAxisValues ( AxisDefinitions  axisDefinitions, const SkFontArguments::VariationPosition  position, SkFixed *  axisValues, const SkString &  name, SkFontStyle *  style, const SkFontArguments::VariationPosition::Coordinate *  currentPosition = nullptr  )

static

Definition at line 2277 of file SkFontHost_FreeType.cpp.

{
    static constexpr SkFourByteTag wghtTag = SkSetFourByteTag('w', 'g', 'h', 't');
    static constexpr SkFourByteTag wdthTag = SkSetFourByteTag('w', 'd', 't', 'h');
    static constexpr SkFourByteTag slntTag = SkSetFourByteTag('s', 'l', 'n', 't');
    int weight = SkFontStyle::kNormal_Weight;
    int width = SkFontStyle::kNormal_Width;
    SkFontStyle::Slant slant = SkFontStyle::kUpright_Slant;
    if (style) {
        weight = style->weight();
        width = style->width();
        slant = style->slant();
    }
 
    for (int i = 0; i < axisDefinitions.size(); ++i) {
        const AxisDefinition& axisDefinition = axisDefinitions[i];
        const SkScalar axisMin = axisDefinition.fMinimum;
        const SkScalar axisMax = axisDefinition.fMaximum;
 
        // Start with the default value.
        axisValues[i] = SkScalarToFixed(axisDefinition.fDefault);
 
        // Then the current value.
        if (current) {
            for (int j = 0; j < axisDefinitions.size(); ++j) {
                const auto& coordinate = current[j];
                if (axisDefinition.fTag == coordinate.axis) {
                    const SkScalar axisValue = SkTPin(coordinate.value, axisMin, axisMax);
                    axisValues[i] = SkScalarToFixed(axisValue);
                    break;
                }
            }
        }
 
        // Then the requested value.
        // The position may be over specified. If there are multiple values for a given axis,
        // use the last one since that's what css-fonts-4 requires.
        for (int j = position.coordinateCount; j --> 0;) {
            const auto& coordinate = position.coordinates[j];
            if (axisDefinition.fTag == coordinate.axis) {
                const SkScalar axisValue = SkTPin(coordinate.value, axisMin, axisMax);
                if (coordinate.value != axisValue) {
                    LOG_INFO("Requested font axis value out of range: "
                            "%s '%c%c%c%c' %f; pinned to %f.\n",
                            name.c_str(),
                            (axisDefinition.fTag >> 24) & 0xFF,
                            (axisDefinition.fTag >> 16) & 0xFF,
                            (axisDefinition.fTag >>  8) & 0xFF,
                            (axisDefinition.fTag      ) & 0xFF,
                            SkScalarToDouble(coordinate.value),
                            SkScalarToDouble(axisValue));
                }
                axisValues[i] = SkScalarToFixed(axisValue);
                break;
            }
        }
 
        if (style) {
            if (axisDefinition.fTag == wghtTag) {
                // Rough validity check, is there sufficient spread and are ranges within 0-1000.
                SkScalar wghtRange = axisMax - axisMin;
                if (wghtRange > 5 && wghtRange <= 1000 && axisMax <= 1000) {
                    weight = SkFixedRoundToInt(axisValues[i]);
                }
            }
            if (axisDefinition.fTag == wdthTag) {
                // Rough validity check, is there a spread and are ranges within 0-500.
                SkScalar wdthRange = axisMax - axisMin;
                if (wdthRange > 0 && wdthRange <= 500 && axisMax <= 500) {
                    SkScalar wdthValue = SkFixedToScalar(axisValues[i]);
                    width = SkFontDescriptor::SkFontStyleWidthForWidthAxisValue(wdthValue);
                }
            }
            if (axisDefinition.fTag == slntTag) {
                // https://docs.microsoft.com/en-us/typography/opentype/spec/dvaraxistag_slnt
                // "Scale interpretation: Values can be interpreted as the angle,
                // in counter-clockwise degrees, of oblique slant from whatever
                // the designer considers to be upright for that font design."
                if (axisValues[i] == 0) {
                    slant = SkFontStyle::kUpright_Slant;
                } else {
                    slant = SkFontStyle::kOblique_Slant;
                }
            }
        }
        // TODO: warn on defaulted axis?
    }
 
    if (style) {
        *style = SkFontStyle(weight, width, slant);
    }
 
    SkDEBUGCODE(
        // Check for axis specified, but not matched in font.
        for (int i = 0; i < position.coordinateCount; ++i) {
            SkFourByteTag skTag = position.coordinates[i].axis;
            bool found = false;
            for (int j = 0; j < axisDefinitions.size(); ++j) {
                if (skTag == axisDefinitions[j].fTag) {
                    found = true;
                    break;
                }
            }
            if (!found) {
                LOG_INFO("Requested font axis not found: %s '%c%c%c%c'\n",
                            name.c_str(),
                            (skTag >> 24) & 0xFF,
                            (skTag >> 16) & 0xFF,
                            (skTag >>  8) & 0xFF,
                            (skTag)       & 0xFF);
            }
        }
    )
}

GetAxes()

bool SkFontScanner_FreeType::GetAxes ( FT_Face  face, AxisDefinitions *  axes  )

static

Definition at line 2253 of file SkFontHost_FreeType.cpp.

                                                                        {
    SkASSERT(face && axes);
    if (face->face_flags & FT_FACE_FLAG_MULTIPLE_MASTERS) {
        FT_MM_Var* variations = nullptr;
        FT_Error err = FT_Get_MM_Var(face, &variations);
        if (err) {
            LOG_INFO("INFO: font %s claims to have variations, but none found.\n",
                     face->family_name);
            return false;
        }
        UniqueVoidPtr autoFreeVariations(variations);
 
        axes->reset(variations->num_axis);
        for (FT_UInt i = 0; i < variations->num_axis; ++i) {
            const FT_Var_Axis& ftAxis = variations->axis[i];
            (*axes)[i].fTag = ftAxis.tag;
            (*axes)[i].fMinimum = SkFT_FixedToScalar(ftAxis.minimum);
            (*axes)[i].fDefault = SkFT_FixedToScalar(ftAxis.def);
            (*axes)[i].fMaximum = SkFT_FixedToScalar(ftAxis.maximum);
        }
    }
    return true;
}

scanFace()

bool SkFontScanner_FreeType::scanFace ( SkStreamAsset *  stream, int  faceIndex, int *  numInstances  ) const

overridevirtual

Implements SkFontScanner.

Definition at line 2083 of file SkFontHost_FreeType.cpp.

                                                               {
    SkAutoMutexExclusive libraryLock(fLibraryMutex);
 
    FT_StreamRec streamRec;
    SkUniqueFTFace face(this->openFace(stream, -(faceIndex + 1), &streamRec));
    if (!face) {
        return false;
    }
 
    *numInstances = face->style_flags >> 16;
    return true;
}

scanFile()

bool SkFontScanner_FreeType::scanFile ( SkStreamAsset *  stream, int *  numFaces  ) const

overridevirtual

Implements SkFontScanner.

Definition at line 2070 of file SkFontHost_FreeType.cpp.

                                                                                {
    SkAutoMutexExclusive libraryLock(fLibraryMutex);
 
    FT_StreamRec streamRec;
    SkUniqueFTFace face(this->openFace(stream, -1, &streamRec));
    if (!face) {
        return false;
    }
 
    *numFaces = face->num_faces;
    return true;
}

scanInstance()

bool SkFontScanner_FreeType::scanInstance ( SkStreamAsset *  stream, int  faceIndex, int  instanceIndex, SkString *  name, SkFontStyle *  style, bool *  isFixedPitch, AxisDefinitions *  axes  ) const

overridevirtual

Implements SkFontScanner.

Definition at line 2098 of file SkFontHost_FreeType.cpp.

                                                                       {
 
    SkAutoMutexExclusive libraryLock(fLibraryMutex);
 
    FT_StreamRec streamRec;
    SkUniqueFTFace face(this->openFace(stream, (instanceIndex << 16) + faceIndex, &streamRec));
    if (!face) {
        return false;
    }
 
    int weight = SkFontStyle::kNormal_Weight;
    int width = SkFontStyle::kNormal_Width;
    SkFontStyle::Slant slant = SkFontStyle::kUpright_Slant;
    if (face->style_flags & FT_STYLE_FLAG_BOLD) {
        weight = SkFontStyle::kBold_Weight;
    }
    if (face->style_flags & FT_STYLE_FLAG_ITALIC) {
        slant = SkFontStyle::kItalic_Slant;
    }
 
    bool hasAxes = face->face_flags & FT_FACE_FLAG_MULTIPLE_MASTERS;
    TT_OS2* os2 = static_cast<TT_OS2*>(FT_Get_Sfnt_Table(face.get(), ft_sfnt_os2));
    bool hasOs2 = os2 && os2->version != 0xffff;
 
    PS_FontInfoRec psFontInfo;
 
    if (hasOs2) {
        weight = os2->usWeightClass;
        width = os2->usWidthClass;
 
        // OS/2::fsSelection bit 9 indicates oblique.
        if (SkToBool(os2->fsSelection & (1u << 9))) {
            slant = SkFontStyle::kOblique_Slant;
        }
    }
 
    // Let variable axes override properties from the OS/2 table.
    if (hasAxes) {
        AxisDefinitions axisDefinitions;
        if (GetAxes(face.get(), &axisDefinitions)) {
            size_t numAxes = axisDefinitions.size();
            static constexpr SkFourByteTag wghtTag = SkSetFourByteTag('w', 'g', 'h', 't');
            static constexpr SkFourByteTag wdthTag = SkSetFourByteTag('w', 'd', 't', 'h');
            static constexpr SkFourByteTag slntTag = SkSetFourByteTag('s', 'l', 'n', 't');
            std::optional<size_t> wghtIndex;
            std::optional<size_t> wdthIndex;
            std::optional<size_t> slntIndex;
            for(size_t i = 0; i < numAxes; ++i) {
                if (axisDefinitions[i].fTag == wghtTag) {
                    // Rough validity check, sufficient spread and ranges within 0-1000.
                    SkScalar wghtRange = axisDefinitions[i].fMaximum - axisDefinitions[i].fMinimum;
                    if (wghtRange > 5 && wghtRange <= 1000 && axisDefinitions[i].fMaximum <= 1000) {
                        wghtIndex = i;
                    }
                }
                if (axisDefinitions[i].fTag == wdthTag) {
                    // Rough validity check, sufficient spread and are ranges within 0-500.
                    SkScalar wdthRange = axisDefinitions[i].fMaximum - axisDefinitions[i].fMinimum;
                    if (wdthRange > 0 && wdthRange <= 500 && axisDefinitions[i].fMaximum <= 500) {
                        wdthIndex = i;
                    }
                }
                if (axisDefinitions[i].fTag == slntTag) {
                    slntIndex = i;
                }
            }
            AutoSTMalloc<4, FT_Fixed> coords(numAxes);
            if ((wghtIndex || wdthIndex || slntIndex) &&
                !FT_Get_Var_Design_Coordinates(face.get(), numAxes, coords.get())) {
                if (wghtIndex) {
                    SkASSERT(*wghtIndex < numAxes);
                    weight = SkFixedRoundToInt(coords[*wghtIndex]);
                }
                if (wdthIndex) {
                    SkASSERT(*wdthIndex < numAxes);
                    SkScalar wdthValue = SkFixedToScalar(coords[*wdthIndex]);
                    width = SkFontDescriptor::SkFontStyleWidthForWidthAxisValue(wdthValue);
                }
                if (slntIndex) {
                    SkASSERT(*slntIndex < numAxes);
                    // https://docs.microsoft.com/en-us/typography/opentype/spec/dvaraxistag_slnt
                    // "Scale interpretation: Values can be interpreted as the angle,
                    // in counter-clockwise degrees, of oblique slant from whatever
                    // the designer considers to be upright for that font design."
                    if (SkFixedToScalar(coords[*slntIndex]) < 0) {
                        slant = SkFontStyle::kOblique_Slant;
                    }
                }
            }
        }
    }
 
    if (!hasOs2 && !hasAxes && 0 == FT_Get_PS_Font_Info(face.get(), &psFontInfo) && psFontInfo.weight) {
        static const struct {
            char const * const name;
            int const weight;
        } commonWeights [] = {
                // There are probably more common names, but these are known to exist.
                { "all", SkFontStyle::kNormal_Weight }, // Multiple Masters usually default to normal.
                { "black", SkFontStyle::kBlack_Weight },
                { "bold", SkFontStyle::kBold_Weight },
                { "book", (SkFontStyle::kNormal_Weight + SkFontStyle::kLight_Weight)/2 },
                { "demi", SkFontStyle::kSemiBold_Weight },
                { "demibold", SkFontStyle::kSemiBold_Weight },
                { "extra", SkFontStyle::kExtraBold_Weight },
                { "extrabold", SkFontStyle::kExtraBold_Weight },
                { "extralight", SkFontStyle::kExtraLight_Weight },
                { "hairline", SkFontStyle::kThin_Weight },
                { "heavy", SkFontStyle::kBlack_Weight },
                { "light", SkFontStyle::kLight_Weight },
                { "medium", SkFontStyle::kMedium_Weight },
                { "normal", SkFontStyle::kNormal_Weight },
                { "plain", SkFontStyle::kNormal_Weight },
                { "regular", SkFontStyle::kNormal_Weight },
                { "roman", SkFontStyle::kNormal_Weight },
                { "semibold", SkFontStyle::kSemiBold_Weight },
                { "standard", SkFontStyle::kNormal_Weight },
                { "thin", SkFontStyle::kThin_Weight },
                { "ultra", SkFontStyle::kExtraBold_Weight },
                { "ultrablack", SkFontStyle::kExtraBlack_Weight },
                { "ultrabold", SkFontStyle::kExtraBold_Weight },
                { "ultraheavy", SkFontStyle::kExtraBlack_Weight },
                { "ultralight", SkFontStyle::kExtraLight_Weight },
        };
        int const index = SkStrLCSearch(&commonWeights[0].name, std::size(commonWeights),
                                        psFontInfo.weight, sizeof(commonWeights[0]));
        if (index >= 0) {
            weight = commonWeights[index].weight;
        } else {
            LOG_INFO("Do not know weight for: %s (%s) \n", face->family_name, psFontInfo.weight);
        }
    }
 
    if (name != nullptr) {
        name->set(face->family_name);
    }
    if (style != nullptr) {
        *style = SkFontStyle(weight, width, slant);
    }
    if (isFixedPitch != nullptr) {
        *isFixedPitch = FT_IS_FIXED_WIDTH(face);
    }
 
    if (axes != nullptr && !GetAxes(face.get(), axes)) {
        return false;
    }
    return true;
}

---

The documentation for this class was generated from the following files:

• third_party/skia/src/ports/SkTypeface_FreeType.h
• third_party/skia/src/ports/SkFontHost_FreeType.cpp