[Git][freetype/freetype-demos][gsoc-2022-chariri-3] [ftinspect] Add SFNT

Charlie Jiang pushed to branch gsoc-2022-chariri-3 at FreeType / FreeType Demo Programs

Commits:

1afa70cb

by Charlie Jiang at 2022-08-19T00:52:36+08:00

[ftinspect] Add SFNT Tables to Font Info tab.

The SFNT Tables read *all tables from the file*, so we can know which faces
are sharing one table. This implemented by reading the file directly and
parse the SFNT headers without FreeType.

WIP: Lots of check and sanitizing aren't done.

* src/ftinspect/engine/fontinfo.cpp, src/ftinspect/engine/fontinfo.hpp:
  Add `SFNTTableInfo`.

* src/ftinspect/models/fontinfomodels.cpp,
  src/ftinspect/models/fontinfomodels.pp:
  Add `SFNTTableInfoModel`, tackle tag endianness issue.

* src/ftinspect/panels/info.cpp, src/ftinspect/panels/info.hpp:
  Integrate `SFNTTableInfoModel`.

* src/ftinspect/engine/engine.cpp, src/ftinspect/engine/engine.hpp:
  Add `curSFNTTablesValid_` and `curSFNTTables_`. Retrieve the SFNT table
  info lazily and add getters.

8 changed files:

src/ftinspect/engine/engine.cpp
src/ftinspect/engine/engine.hpp
src/ftinspect/engine/fontinfo.cpp
src/ftinspect/engine/fontinfo.hpp
src/ftinspect/models/fontinfomodels.cpp
src/ftinspect/models/fontinfomodels.hpp
src/ftinspect/panels/info.cpp
src/ftinspect/panels/info.hpp

Changes:

src/ftinspect/engine/engine.cpp

@@ -282,6 +282,7 @@ Engine::loadFont(int fontIndex,
    fontType_ = FontType_Other;
    update();
 +  curSFNTTablesValid_ = false;
    curFontIndex_ = fontIndex;
    auto id = FaceID(fontIndex, faceIndex, namedInstanceIndex);
@@ -491,6 +492,19 @@ Engine::currentFontPSPrivateInfo(PS_PrivateRec& outInfo)
+ }
 +std::vector<SFNTTableInfo>&
 +Engine::currentFontSFNTTableInfo()
 +{
 +  if (!curSFNTTablesValid_)
 +  {
 +    SFNTTableInfo::getForAll(this, curSFNTTables_);
 +    curSFNTTablesValid_ = true;
 +  }
++
 +  return curSFNTTables_;
 +}
++
++
  QString
  Engine::glyphName(int index)
+ {

src/ftinspect/engine/engine.hpp

@@ -161,6 +161,7 @@ public:
    std::vector<SFNTName>& currentFontSFNTNames() { return curSFNTNames_; }
    MMGXState currentFontMMGXState() { return curMMGXState_; }
    std::vector<MMGXAxisInfo>& currentFontMMGXAxes() { return curMMGXAxes_; }
 +  std::vector<SFNTTableInfo>& currentFontSFNTTableInfo();
    FontFileManager& fontFileManager() { return fontFileManager_; }
    EngineDefaultValues& engineDefaults() { return engineDefaults_; }
    bool antiAliasingEnabled() { return antiAliasingEnabled_; }
@@ -233,6 +234,9 @@ private:
    std::vector<CharMapInfo> curCharMaps_;
    std::vector<PaletteInfo> curPaletteInfos_;
    std::vector<MMGXAxisInfo> curMMGXAxes_;
++
 +  bool curSFNTTablesValid_ = false;
 +  std::vector<SFNTTableInfo> curSFNTTables_;
    MMGXState curMMGXState_ = MMGXState::NoMMGX;
    FT_Library library_;

src/ftinspect/engine/fontinfo.cpp

@@ -6,7 +6,9 @@
  #include "engine.hpp"
 +#include <map>
  #include <unordered_map>
 +#include <memory>
  #include <utility>
  #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
  #include <QTextCodec>
@@ -17,11 +19,18 @@
  #include <freetype/ftmodapi.h>
  #include <freetype/ttnameid.h>
  #include <freetype/tttables.h>
 +#include <freetype/tttags.h>
++
 +#ifdef _MSC_VER // To use intrin
 +#define WIN32_LEAN_AND_MEAN
 +#include <Windows.h>
 +#include <intrin.h>
 +#endif
  void
  SFNTName::get(Engine* engine,
 -  std::vector<SFNTName>& list)
 +              std::vector<SFNTName>& list)
+ {
    auto size = engine->currentFtSize();
    if (!size || !FT_IS_SFNT(size->face))
@@ -369,4 +378,202 @@ FontFixedSize::get(Engine* engine,
+ }
 +struct TTCHeaderRec
 +{
 +  uint32_t ttcTag;
 +  uint16_t majorVersion;
 +  uint16_t minorVersion;
 +  uint32_t numFonts;
 +};
++
++
 +struct SFNTHeaderRec
 +{
 +  uint32_t formatTag;
 +  uint16_t numTables;
 +  // There'll be some padding, but it doesn't matter.
 +};
++
++
 +struct TTTableRec
 +{
 +  uint32_t tag;
 +  uint32_t checksum;
 +  uint32_t offset;
 +  uint32_t length;
 +};
++
++
 +uint32_t
 +bigEndianToNative(uint32_t n)
 +{
 +#ifdef _MSC_VER
 +  #if REG_DWORD == REG_DWORD_LITTLE_ENDIAN
 +    return _byteswap_ulong(n);
 +  #else
 +    return n;
 +  #endif
 +#else
 +  auto np = reinterpret_cast<unsigned char*>(&n);
++
 +  return (static_cast<uint32_t>(np[0]) << 24)
 +         | (static_cast<uint32_t>(np[1]) << 16)
 +         | (static_cast<uint32_t>(np[2]) << 8)
 +         | (static_cast<uint32_t>(np[3]));
 +#endif
 +}
++
++
 +uint16_t
 +bigEndianToNative(uint16_t n)
 +{
 +#ifdef _MSC_VER
 +#if REG_DWORD == REG_DWORD_LITTLE_ENDIAN
 +  return _byteswap_ushort(n);
 +#else
 +  return n;
 +#endif
 +#else
 +  auto np = reinterpret_cast<unsigned char*>(&n);
++
 +  return static_cast<uint16_t>((static_cast<uint16_t>(np[0]) << 8)
 +                               | (static_cast<uint16_t>(np[1])));
 +#endif
 +}
++
++
 +void readSingleFace(QFile& file,
 +                    uint32_t offset,
 +                    unsigned faceIndex,
 +                    std::vector<TTTableRec>& tempTables,
 +                    std::map<unsigned long, SFNTTableInfo>& result)
 +{
 +  if (!file.seek(offset))
 +    return;
++
 +  SFNTHeaderRec sfntHeader = {};
 +  if (file.read(reinterpret_cast<char*>(&sfntHeader),
 +                sizeof(SFNTHeaderRec))
 +      != sizeof(SFNTHeaderRec))
 +    return;
 +  sfntHeader.formatTag = bigEndianToNative(sfntHeader.formatTag);
 +  sfntHeader.numTables = bigEndianToNative(sfntHeader.numTables);
++
 +  unsigned short validEntries = sfntHeader.numTables;
++
 +  if (sfntHeader.formatTag != TTAG_OTTO)
 +  {
 +    // TODO check SFNT Header
 +    //checkSFNTHeader();
 +  }
++
 +  if (!file.seek(offset + 12))
 +    return;
++
 +  tempTables.resize(validEntries);
 +  auto desiredLen = static_cast<long long>(validEntries * sizeof(TTTableRec));
 +  auto readLen = file.read(reinterpret_cast<char*>(tempTables.data()), desiredLen);
 +  if (readLen != desiredLen)
 +    return;
++
 +  for (auto& t : tempTables)
 +  {
 +    t.tag = bigEndianToNative(t.tag);
 +    t.offset = bigEndianToNative(t.offset);
 +    t.checksum = bigEndianToNative(t.checksum);
 +    t.length = bigEndianToNative(t.length);
++
 +    auto it = result.find(t.offset);
 +    if (it == result.end())
 +    {
 +      auto emplaced = result.emplace(t.offset, SFNTTableInfo());
 +      it = emplaced.first;
++
 +      auto& info = it->second;
 +      info.tag = t.tag;
 +      info.length = t.length;
 +      info.offset = t.offset;
 +      info.sharedFaces.emplace(faceIndex);
 +      info.valid = true;
 +    }
 +    else
 +    {
 +      it->second.sharedFaces.emplace(faceIndex);
 +      // TODO check
 +    }
 +  }
 +}
++
++
 +void
 +SFNTTableInfo::getForAll(Engine* engine,
 +                         std::vector<SFNTTableInfo>& infos)
 +{
 +  infos.clear();
 +  auto size = engine->currentFtSize();
 +  if (!size || !FT_IS_SFNT(size->face))
 +    return;
++
 +  auto index = engine->currentFontIndex();
 +  auto& mgr = engine->fontFileManager();
 +  if (index < 0 || index >= mgr.size())
 +    return;
++
 +  auto& fileInfo = mgr[index];
 +  QFile file(fileInfo.filePath());
 +  if (!file.open(QIODevice::ReadOnly))
 +    return;
++
 +  auto fileSize = file.size();
 +  if (fileSize < 12)
 +    return;
++
 +  std::vector<TTTableRec> tables;
 +  std::map<unsigned long, SFNTTableInfo> result;
++
 +  TTCHeaderRec ttcHeader = {};
 +  auto readLen = file.read(reinterpret_cast<char*>(&ttcHeader),
 +                           sizeof(TTCHeaderRec));
++
 +  if (readLen != sizeof(TTCHeaderRec))
 +    return;
++
 +  ttcHeader.ttcTag = bigEndianToNative(ttcHeader.ttcTag);
 +  ttcHeader.majorVersion = bigEndianToNative(ttcHeader.majorVersion);
 +  ttcHeader.minorVersion = bigEndianToNative(ttcHeader.minorVersion);
 +  ttcHeader.numFonts = bigEndianToNative(ttcHeader.numFonts);
++
 +  if (ttcHeader.ttcTag == TTAG_ttcf
 +      && (ttcHeader.majorVersion == 2 || ttcHeader.majorVersion == 1))
 +  {
 +    // Valid TTC file
 +    std::unique_ptr<unsigned> offsets(new unsigned[ttcHeader.numFonts]);
 +    auto desiredLen = static_cast<long long>(ttcHeader.numFonts
 +                                             * sizeof(unsigned));
 +    readLen = file.read(reinterpret_cast<char*>(offsets.get()), desiredLen);
 +    if (readLen != desiredLen)
 +      return;
++
 +    for (unsigned faceIndex = 0;
 +        faceIndex < ttcHeader.numFonts;
 +        faceIndex++)
 +    {
 +      auto offset = bigEndianToNative(offsets.get()[faceIndex]);
 +      readSingleFace(file, offset, faceIndex, tables, result);
 +    }
 +  }
 +  else
 +  {
 +    // Not TTC file, try single SFNT
 +    if (!file.seek(0))
 +      return;
 +    readSingleFace(file, 0, 0, tables, result);
 +  }
++
 +  infos.reserve(result.size());
 +  for (auto& pr : result)
 +    infos.emplace_back(std::move(pr.second));
 +}
++
++
  // end of fontinfo.cpp

src/ftinspect/engine/fontinfo.hpp

@@ -4,6 +4,7 @@
  #pragma once
 +#include <set>
  #include <QDateTime>
  #include <QByteArray>
  #include <QString>
@@ -13,6 +14,38 @@
  class Engine;
 +struct SFNTTableInfo
 +{
 +  unsigned long tag = 0;
 +  unsigned long offset = 0;
 +  unsigned long length = 0;
 +  bool valid = false;
 +  std::set<unsigned long> sharedFaces;
++
 +  static void getForAll(Engine* engine, std::vector<SFNTTableInfo>& infos);
++
++
 +  friend bool
 +  operator==(const SFNTTableInfo& lhs,
 +             const SFNTTableInfo& rhs)
 +  {
 +    return lhs.tag == rhs.tag
 +      && lhs.offset == rhs.offset
 +      && lhs.length == rhs.length
 +      && lhs.valid == rhs.valid
 +      && lhs.sharedFaces == rhs.sharedFaces;
 +  }
++
++
 +  friend bool
 +  operator!=(const SFNTTableInfo& lhs,
 +             const SFNTTableInfo& rhs)
 +  {
 +    return !(lhs == rhs);
 +  }
 +};
++
++
  struct SFNTName
+ {
    unsigned short nameID;

src/ftinspect/models/fontinfomodels.cpp

@@ -270,6 +270,113 @@ SFNTNameModel::headerData(int section,
+ }
 +QString
 +tagToString(unsigned long tag)
 +{
 +  QString str(4, '0');
 +  str[0] = static_cast<char>(tag >> 24);
 +  str[1] = static_cast<char>(tag >> 16);
 +  str[2] = static_cast<char>(tag >> 8);
 +  str[3] = static_cast<char>(tag);
 +  return str;
 +}
++
++
 +int
 +SFNTTableInfoModel::rowCount(const QModelIndex& parent) const
 +{
 +  if (parent.isValid())
 +    return 0;
 +  return static_cast<int>(storage_.size());
 +}
++
++
 +int
 +SFNTTableInfoModel::columnCount(const QModelIndex& parent) const
 +{
 +  if (parent.isValid())
 +    return 0;
 +  return STIM_Max;
 +}
++
++
 +QVariant
 +SFNTTableInfoModel::data(const QModelIndex& index,
 +                         int role) const
 +{
 +  if (index.row() < 0 || index.column() < 0)
 +    return {};
 +  auto r = static_cast<size_t>(index.row());
 +  if (role != Qt::DisplayRole || r > storage_.size())
 +    return {};
++
 +  auto& obj = storage_[r];
 +  switch (static_cast<Columns>(index.column()))
 +  {
 +  case STIM_Tag:
 +    return tagToString(obj.tag);
 +  case STIM_Offset:
 +    return static_cast<unsigned long long>(obj.offset);
 +  case STIM_Length:
 +    return static_cast<unsigned long long>(obj.length);
 +  case STIM_Valid:
 +    return obj.valid;
 +  case STIM_SharedFaces:
 +    if (obj.sharedFaces.empty())
 +      return "[]";
 +  {
 +    auto result = QString('[') + QString::number(*obj.sharedFaces.begin());
 +    for (auto it = std::next(obj.sharedFaces.begin());
 +         it != obj.sharedFaces.end();
 +         ++it)
 +    {
 +      auto xStr = QString::number(*it);
 +      result.reserve(result.length() + xStr.length() + 2);
 +      result += ", ";
 +      result += xStr;
 +    }
 +    result += ']';
 +    return result;
 +  }
 +  default:
 +    break;
 +  }
++
 +  return {};
 +}
++
++
 +QVariant
 +SFNTTableInfoModel::headerData(int section,
 +                               Qt::Orientation orientation,
 +                               int role) const
 +{
 +  if (role != Qt::DisplayRole)
 +    return {};
 +  if (orientation == Qt::Vertical)
 +    return section;
 +  if (orientation != Qt::Horizontal)
 +    return {};
++
 +  switch (static_cast<Columns>(section))
 +  {
 +  case STIM_Tag:
 +    return "Tag";
 +  case STIM_Offset:
 +    return "Offset";
 +  case STIM_Length:
 +    return "Length";
 +  case STIM_Valid:
 +    return "Valid";
 +  case STIM_SharedFaces:
 +    return "Subfont Indices";
 +  default:;
 +  }
++
 +  return {};
 +}
++
++
  int
  MMGXAxisInfoModel::rowCount(const QModelIndex& parent) const
+ {
@@ -302,11 +409,7 @@ MMGXAxisInfoModel::data(const QModelIndex& index,
    switch (static_cast<Columns>(index.column()))
+   {
    case MAIM_Tag:
 -  {
 -    auto str = QString::fromUtf8(reinterpret_cast<const char*>(&obj.tag), 4);
 -    std::reverse(str.begin(), str.end());
 -    return str;
 -  }
 +    return tagToString(obj.tag);
    case MAIM_Minimum:
      return obj.minimum;
    case MAIM_Default:

src/ftinspect/models/fontinfomodels.hpp

@@ -128,6 +128,43 @@ private:
  };
 +class SFNTTableInfoModel
 +: public QAbstractTableModel
 +{
 +  Q_OBJECT
 +public:
 +  explicit SFNTTableInfoModel(QObject* parent) : QAbstractTableModel(parent) {}
 +  ~SFNTTableInfoModel() override = default;
++
 +  int rowCount(const QModelIndex& parent) const override;
 +  int columnCount(const QModelIndex& parent) const override;
 +  QVariant data(const QModelIndex& index,
 +                int role) const override;
 +  QVariant headerData(int section,
 +                      Qt::Orientation orientation,
 +                      int role) const override;
++
 +  // Same to `FixedSizeInfoModel`
 +  void beginModelUpdate() { beginResetModel(); }
 +  void endModelUpdate() { endResetModel(); }
 +  std::vector<SFNTTableInfo>& storage() { return storage_; }
++
 +  enum Columns : int
 +  {
 +    STIM_Tag = 0,
 +    STIM_Offset,
 +    STIM_Length,
 +    STIM_Valid,
 +    STIM_SharedFaces,
 +    STIM_Max
 +  };
++
 +private:
 +  // Don't let the item count exceed INT_MAX!
 +  std::vector<SFNTTableInfo> storage_;
 +};
++
++
  class MMGXAxisInfoModel
  : public QAbstractTableModel
+ {

src/ftinspect/panels/info.cpp

@@ -424,6 +424,13 @@ SFNTInfoTab::reloadFont()
      sfntNamesModel_->storage() = engine_->currentFontSFNTNames();
      sfntNamesModel_->endModelUpdate();
+   }
++
 +  if (engine_->currentFontSFNTTableInfo() != sfntTablesModel_->storage())
 +  {
 +    sfntTablesModel_->beginModelUpdate();
 +    sfntTablesModel_->storage() = engine_->currentFontSFNTTableInfo();
 +    sfntTablesModel_->endModelUpdate();
 +  }
+ }
@@ -444,10 +451,13 @@ SFNTInfoTab::createLayout()
    header->setSectionResizeMode(QHeaderView::Fixed);
    sfntNamesTable_->horizontalHeader()->setStretchLastSection(true);
 +  sfntTablesModel_ = new SFNTTableInfoModel(this);
 +  sfntTablesTable_->setModel(sfntTablesModel_);
    header = sfntTablesTable_->verticalHeader();
    // This will force the minimal size to be used
    header->setDefaultSectionSize(0);
    header->setSectionResizeMode(QHeaderView::Fixed);
 +  sfntTablesTable_->horizontalHeader()->setStretchLastSection(true);
    sfntNamesLayout_ = new QHBoxLayout;
    sfntTablesLayout_ = new QHBoxLayout;

src/ftinspect/panels/info.hpp

@@ -172,6 +172,7 @@ private:
    QTableView* sfntTablesTable_;
    SFNTNameModel* sfntNamesModel_;
 +  SFNTTableInfoModel* sfntTablesModel_;
    QHBoxLayout* sfntNamesLayout_;
    QHBoxLayout* sfntTablesLayout_;

From:	Charlie Jiang (@cqjjjzr)
Subject:	[Git][freetype/freetype-demos][gsoc-2022-chariri-3] [ftinspect] Add SFNT Tables to Font Info tab.
Date:	Thu, 18 Aug 2022 16:52:52 +0000