gecko-dev/gfx/2d/SFNTData.cpp

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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 "SFNTData.h"

#include <algorithm>

#include "BigEndianInts.h"
#include "Logging.h"
#include "mozilla/HashFunctions.h"
#include "SFNTNameTable.h"

namespace mozilla {
namespace gfx {

#define TRUETYPE_TAG(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d))

#pragma pack(push, 1)

struct TTCHeader {
  BigEndianUint32 ttcTag;   // Always 'ttcf'
  BigEndianUint32 version;  // Fixed, 0x00010000
  BigEndianUint32 numFonts;
};

struct OffsetTable {
  BigEndianUint32 sfntVersion;  // Fixed, 0x00010000 for version 1.0.
  BigEndianUint16 numTables;
  BigEndianUint16 searchRange;    // (Maximum power of 2 <= numTables) x 16.
  BigEndianUint16 entrySelector;  // Log2(maximum power of 2 <= numTables).
  BigEndianUint16 rangeShift;     // NumTables x 16-searchRange.
};

struct TableDirEntry {
  BigEndianUint32 tag;       // 4 -byte identifier.
  BigEndianUint32 checkSum;  // CheckSum for this table.
  BigEndianUint32 offset;    // Offset from beginning of TrueType font file.
  BigEndianUint32 length;    // Length of this table.

  friend bool operator<(const TableDirEntry& lhs, const uint32_t aTag) {
    return lhs.tag < aTag;
  }
};

#pragma pack(pop)

class SFNTData::Font {
 public:
  Font(const OffsetTable* aOffsetTable, const uint8_t* aFontData,
       uint32_t aDataLength)
      : mFontData(aFontData),
        mFirstDirEntry(
            reinterpret_cast<const TableDirEntry*>(aOffsetTable + 1)),
        mEndOfDirEntries(mFirstDirEntry + aOffsetTable->numTables),
        mDataLength(aDataLength) {}

  bool GetU16FullName(mozilla::u16string& aU16FullName) {
    const TableDirEntry* dirEntry =
        GetDirEntry(TRUETYPE_TAG('n', 'a', 'm', 'e'));
    if (!dirEntry) {
      gfxWarning() << "Name table entry not found.";
      return false;
    }

    UniquePtr<SFNTNameTable> nameTable =
        SFNTNameTable::Create((mFontData + dirEntry->offset), dirEntry->length);
    if (!nameTable) {
      return false;
    }

    return nameTable->GetU16FullName(aU16FullName);
  }

 private:
  const TableDirEntry* GetDirEntry(const uint32_t aTag) {
    const TableDirEntry* foundDirEntry =
        std::lower_bound(mFirstDirEntry, mEndOfDirEntries, aTag);

    if (foundDirEntry == mEndOfDirEntries || foundDirEntry->tag != aTag) {
      gfxWarning() << "Font data does not contain tag.";
      return nullptr;
    }

    if (mDataLength < (foundDirEntry->offset + foundDirEntry->length)) {
      gfxWarning() << "Font data too short to contain table.";
      return nullptr;
    }

    return foundDirEntry;
  }

  const uint8_t* mFontData;
  const TableDirEntry* mFirstDirEntry;
  const TableDirEntry* mEndOfDirEntries;
  uint32_t mDataLength;
};

/* static */
UniquePtr<SFNTData> SFNTData::Create(const uint8_t* aFontData,
                                     uint32_t aDataLength) {
  MOZ_ASSERT(aFontData);

  // Check to see if this is a font collection.
  if (aDataLength < sizeof(TTCHeader)) {
    gfxWarning() << "Font data too short.";
    return nullptr;
  }

  const TTCHeader* ttcHeader = reinterpret_cast<const TTCHeader*>(aFontData);
  if (ttcHeader->ttcTag == TRUETYPE_TAG('t', 't', 'c', 'f')) {
    uint32_t numFonts = ttcHeader->numFonts;
    if (aDataLength <
        sizeof(TTCHeader) + (numFonts * sizeof(BigEndianUint32))) {
      gfxWarning() << "Font data too short to contain full TTC Header.";
      return nullptr;
    }

    UniquePtr<SFNTData> sfntData(new SFNTData);
    const BigEndianUint32* offset =
        reinterpret_cast<const BigEndianUint32*>(aFontData + sizeof(TTCHeader));
    const BigEndianUint32* endOfOffsets = offset + numFonts;
    while (offset != endOfOffsets) {
      if (!sfntData->AddFont(aFontData, aDataLength, *offset)) {
        return nullptr;
      }
      ++offset;
    }

    return sfntData;
  }

  UniquePtr<SFNTData> sfntData(new SFNTData);
  if (!sfntData->AddFont(aFontData, aDataLength, 0)) {
    return nullptr;
  }

  return sfntData;
}

/* static */
uint64_t SFNTData::GetUniqueKey(const uint8_t* aFontData, uint32_t aDataLength,
                                uint32_t aVarDataSize, const void* aVarData) {
  uint64_t hash;
  UniquePtr<SFNTData> sfntData = SFNTData::Create(aFontData, aDataLength);
  mozilla::u16string firstName;
  if (sfntData && sfntData->GetU16FullName(0, firstName)) {
    hash = HashString(firstName.c_str(), firstName.length());
  } else {
    gfxWarning() << "Failed to get name from font data hashing whole font.";
    hash = HashString(aFontData, aDataLength);
  }

  if (aVarDataSize) {
    hash = AddToHash(hash, HashBytes(aVarData, aVarDataSize));
  }

  return hash << 32 | aDataLength;
  ;
}

SFNTData::~SFNTData() {
  for (size_t i = 0; i < mFonts.length(); ++i) {
    delete mFonts[i];
  }
}

bool SFNTData::GetU16FullName(uint32_t aIndex,
                              mozilla::u16string& aU16FullName) {
  if (aIndex >= mFonts.length()) {
    gfxWarning() << "aIndex to font data too high.";
    return false;
  }

  return mFonts[aIndex]->GetU16FullName(aU16FullName);
}

bool SFNTData::GetU16FullNames(Vector<mozilla::u16string>& aU16FullNames) {
  bool fontFound = false;
  for (size_t i = 0; i < mFonts.length(); ++i) {
    mozilla::u16string name;
    if (mFonts[i]->GetU16FullName(name)) {
      fontFound = true;
    }
    if (!aU16FullNames.append(std::move(name))) {
      return false;
    }
  }

  return fontFound;
}

bool SFNTData::GetIndexForU16Name(const mozilla::u16string& aU16FullName,
                                  uint32_t* aIndex, size_t aTruncatedLen) {
  for (size_t i = 0; i < mFonts.length(); ++i) {
    mozilla::u16string name;
    if (!mFonts[i]->GetU16FullName(name)) {
      continue;
    }

    if (aTruncatedLen) {
      MOZ_ASSERT(aU16FullName.length() <= aTruncatedLen);
      name = name.substr(0, aTruncatedLen);
    }

    if (name == aU16FullName) {
      *aIndex = i;
      return true;
    }
  }

  return false;
}

bool SFNTData::AddFont(const uint8_t* aFontData, uint32_t aDataLength,
                       uint32_t aOffset) {
  uint32_t remainingLength = aDataLength - aOffset;
  if (remainingLength < sizeof(OffsetTable)) {
    gfxWarning() << "Font data too short to contain OffsetTable " << aOffset;
    return false;
  }

  const OffsetTable* offsetTable =
      reinterpret_cast<const OffsetTable*>(aFontData + aOffset);
  if (remainingLength <
      sizeof(OffsetTable) + (offsetTable->numTables * sizeof(TableDirEntry))) {
    gfxWarning() << "Font data too short to contain tables.";
    return false;
  }

  return mFonts.append(new Font(offsetTable, aFontData, aDataLength));
}

}  // namespace gfx
}  // namespace mozilla