C++字体库开发之WOFF字体解析十四

2025-01-02

本文作者原创，首发在本博客；CSDN 上的同名文章已标注为转载并回链到本页：https://blog.csdn.net/qq_30220519/article/details/144879125

环境准备

git clone –recursive https://github.com/google/woff2

cd brotli
mkdir build && cd build
cmake -DCMAKE_BUILD_TYPE=Release ..
make -j4

目录配置

src下创建CMakeLists.txt

project(test)

set(CMAKE_CXX_STANDARD 20)

file(GLOB_RECURSE SRC ./*.cc)
list(REMOVE_ITEM SRC "woff2_decompress.cc" "woff2_info.cc")

include_directories(.)

add_executable(test ${SRC} main.cpp)
target_link_directories(test PUBLIC .)
target_link_directories(test PUBLIC zlib)
target_link_directories(test PUBLIC woff2)
target_link_directories(test PUBLIC brotli/include)

target_link_libraries(test PUBLIC zlib/zlib)
target_link_libraries(test PUBLIC brotli/lib/brotlicommon)
target_link_libraries(test PUBLIC brotli/lib/brotlidec)
target_link_libraries(test PUBLIC brotli/lib/brotlienc)

main.cpp

#include "zlib/zlib.h"
#include <bit>
#include <cstring>
#include <stdio.h>
#include <vector>
#include "woff2/decode.h"
#include <fstream>

enum FontType {
  COMMON_F,  // ttf ttc otf etc
  WOFF_F,
  WOFF_F2
};

struct FileStream {
  uint8_t* byte = nullptr;
  uint32_t size = 0;

  FileStream() {}
  FileStream(uint32_t s) {
    byte = new uint8_t[s];
    size = s;
  }

  void write(const char *src, uint32_t s, uint32_t &offset) {
    if(s + offset > size) {
       auto oldByte = byte;
       byte = new uint8_t[s + offset];
       memcpy(byte, oldByte, size);
       delete[] oldByte;
       size = s + offset;
    }
    memcpy(byte + offset, src, s);
  }

  void release() {
    delete[] byte;
    byte = nullptr;
    size = 0;
  }
};

struct TableDirectoryEntry {
  uint32_t tag;           // 4-byte sfnt table identifier.
  uint32_t offset;        // Offset to the data, from beginning of WOFF file.
  uint32_t compLength;    // Length of the compressed data, excluding padding.
  uint32_t origLength;    // Length of the uncompressed table, excluding padding.
  uint32_t origChecksum;  // Checksum of the uncompressed table.

  TableDirectoryEntry(const char *const ptr);
};

bool isLittleEndian() {
  return std::endian::native == std::endian::little;
}

uint32_t endianInv32(uint32_t A)
{
  return ((((uint32_t)(A)&0xff000000) >> 24) | (((uint32_t)(A)&0x00ff0000) >> 8) | (((uint32_t)(A)&0x0000ff00) << 8) |
          (((uint32_t)(A)&0x000000ff) << 24));
}

uint16_t endianInv16(uint16_t A)
{
  return (((uint16_t)(A)&0xff00) >> 8) | (((uint16_t)(A)&0x00ff) << 8);
}

uint32_t padding4(uint32_t cur) { return (cur + 3) & 0xFFFFFFFC; }

struct WoffHeader {
  uint32_t signature;       // 0x774F4646 'wOFF'
  uint32_t flavor;          // The "sfnt version" of the input font.
  uint32_t length;          // Total size of the WOFF file.
  uint16_t numTables;       // Number of entries in directory of font tables.
  uint16_t reserved;        // Reserved; set to zero.
  uint32_t totalSfntSize;   // Total size needed for the uncompressed font data, including the sfnt header, directory, and
                           // font tables (including padding).
  uint16_t majorVersion;    // Major version of the WOFF file.
  uint16_t minorVersion;    // Minor version of the WOFF file.
  uint32_t metaOffset;      // Offset to metadata block, from beginning of WOFF file.
  uint32_t metaLength;      // Length of compressed metadata block.
  uint32_t metaOrigLength;  // Uncompressed size of metadata block.
  uint32_t privOffset;      // Offset to private data block, from beginning of WOFF file.
  uint32_t privLength;      // Length of private data block.

  WoffHeader(const char *const ptr) {
    constexpr int standardSize = sizeof(WoffHeader);
    static_assert(standardSize == 44);

    memcpy(this, ptr, standardSize);
    if (isLittleEndian()) {
      signature     = endianInv32(signature);
      flavor        = endianInv32(flavor);
      length        = endianInv32(length);
      numTables     = endianInv16(numTables);
      reserved      = endianInv16(reserved);
      totalSfntSize = endianInv32(totalSfntSize);
      majorVersion  = endianInv16(majorVersion);
      minorVersion  = endianInv16(minorVersion);

      auto *pU32 = (uint32_t *)(&metaOffset);
      for (int i = 0; i < 5; i++, pU32++)
        *pU32 = endianInv32(*pU32);
    }
  }
};

FontType getFontType(uint8_t *data) {
  uint32_t head = *((uint32_t *)data);
  if (isLittleEndian()) {
    head = endianInv32(head);
  }

  if (head == 0x774F4646)
    return WOFF_F;
  if (head == 0x774F4632)
    return WOFF_F2;
  return COMMON_F;
}


TableDirectoryEntry::TableDirectoryEntry(const char *const ptr)
{
  static_assert(sizeof(TableDirectoryEntry) == 20);

  memcpy(this, ptr, sizeof(TableDirectoryEntry));
  if (isLittleEndian()) {  // 转为大端
    auto *pU32 = (uint32_t *)(&tag);
    for (int i = 0; i < 5; i++, pU32++)
      *pU32 = endianInv32(*pU32);
  }
}

char *decompressedNewData(const char *oriFile, size_t oriSize, size_t decompressSize)
{
  if (!oriFile || !oriSize || !decompressSize)
    return nullptr;

  auto outStream = new char[decompressSize];
  int  ret       = uncompress((uint8_t *)outStream,
                       reinterpret_cast<uLongf *>(&decompressSize),
                       reinterpret_cast<const Bytef *>(oriFile),
                       oriSize);
  if (ret != Z_OK) {
    printf("Zlib uncompress fail!");
    delete[] outStream;
    return nullptr;
  }
  return outStream;
}

void writeWithOffset(FileStream &outStream, const char *src, uint32_t size, uint32_t &offset)
{
  outStream.write(src, size, offset);
  offset += size;
}

// 大端写入 python unpack标识 "I" u32 "H" u16
void writeUInt32WithOffset(FileStream &outStream, uint32_t val, uint32_t &offset)
{
  if (isLittleEndian())
    val = endianInv32(val);
  writeWithOffset(outStream, (const char *)&val, 4, offset);
}
void writeUInt16WithOffset(FileStream &outStream, uint16_t val, uint32_t &offset)
{
  if (isLittleEndian())
    val = endianInv16(val);
  writeWithOffset(outStream, (const char *)&val, 2, offset);
}

FileStream woffToOTF(const FileStream &stream)
{
  auto origin = stream.byte;
  auto cur    = origin;

  WoffHeader header((const char*)cur);
  if (header.signature != 0x774F4646 || (header.totalSfntSize % 4) != 0)
    return {};
  cur += sizeof(WoffHeader);

  int numTables = header.numTables;
  int index = 0, base = 1;
  for (; index < 64; index++) {
    if (base * 2 > numTables)
      break;
    base <<= 1;
  }

  int searchRange   = base * 16;
  int entrySelector = index;
  int rangeShift    = numTables * 16 - searchRange;

  FileStream outStream(header.totalSfntSize);
  uint32_t writeOffset = 0;

  writeUInt32WithOffset(outStream, header.flavor, writeOffset);
  writeUInt16WithOffset(outStream, numTables, writeOffset);
  writeUInt16WithOffset(outStream, searchRange, writeOffset);
  writeUInt16WithOffset(outStream, entrySelector, writeOffset);
  writeUInt16WithOffset(outStream, rangeShift, writeOffset);
  
  uint32_t totalSfntSize = 4 + 2 * 4;
  totalSfntSize += 16 * numTables;

  uint32_t                         offset = 4 + 4 * 2;
  std::vector<TableDirectoryEntry> TableDirectoryEntries;
  for (int i = 0; i < numTables; i++) {
    TableDirectoryEntries.emplace_back((const char *)cur);
    cur += sizeof(TableDirectoryEntry);
    offset += 4 * 4;
    totalSfntSize += padding4(TableDirectoryEntries.back().origLength);
  }

  std::vector<uint32_t> outOffsets;
  for (auto &entry : TableDirectoryEntries) {
    writeUInt32WithOffset(outStream, entry.tag, writeOffset);
    writeUInt32WithOffset(outStream, entry.origChecksum, writeOffset);
    writeUInt32WithOffset(outStream, offset, writeOffset);
    writeUInt32WithOffset(outStream, entry.origLength, writeOffset);

    outOffsets.push_back(offset);
    offset += entry.origLength;
    offset = padding4(offset);
  }

  index                 = 0;
  const uint32_t padInt = 0;  // 4 bit 0
  for (auto &entry : TableDirectoryEntries) {
    cur                          = origin + entry.offset;
    const char *uncompressedData = (const char*)cur;
    bool        decompress       = entry.compLength != entry.origLength;
    if (decompress) {
      uncompressedData = decompressedNewData((const char*)cur, entry.compLength, entry.origLength);
      if (!uncompressedData)
        return {};
    }

    uint32_t outOffset = outOffsets[index++];
    writeOffset        = outOffset;
    writeWithOffset(outStream, uncompressedData, entry.origLength, writeOffset);

    offset           = outOffset + entry.origLength;
    uint32_t padding = (offset & 3) ? 4 - (offset & 3) : 0;
    writeWithOffset(outStream, (const char *)(&padInt), padding, writeOffset);

    if (decompress)
      delete[] uncompressedData;
  }

  return outStream;
}

FileStream woff2ToTTF(const FileStream &stream)
{
  const auto *raw_input = reinterpret_cast<const uint8_t *>(stream.byte);
  size_t      inputSize = stream.size;
  size_t      ttfSize   = std::min(woff2::ComputeWOFF2FinalSize(raw_input, inputSize), woff2::kDefaultMaxSize);
  FileStream    ttf(ttfSize);

  const bool ok = woff2::ConvertWOFF2ToTTF((uint8_t *)ttf.byte, ttf.size, raw_input, inputSize);
  if (!ok)
    return {};

  return ttf;
}


FileStream toAvailableFont(const FileStream &stream)
{
  auto type = getFontType(stream.byte);

  FileStream outFile = stream;
  if (type != COMMON_F) {
    if (type == WOFF_F)
      outFile = woffToOTF(stream);
    else
      outFile = woff2ToTTF(stream);
  }
  return outFile;
}

int main() {
  constexpr const char *font = "D:\\可变字体woff\\DecovarAlpha-VF.woff2";

  std::ifstream file(font, std::ios::in | std::ios::binary); 
  if (!file.is_open())
    return 0;

  size_t   bufSize = file.seekg(0, std::ios::end).tellg();
  uint8_t *buf     = nullptr;
  buf              = new uint8_t[bufSize];
  file.seekg(0, std::ios::beg).read((char *)buf, bufSize);
  file.close();

  FileStream fileStream;
  fileStream.byte = buf;
  fileStream.size = bufSize;

  auto type    = getFontType(buf);
  FileStream   outFileStream = toAvailableFont(fileStream);

  const char* outpath = "D:\\可变字体woff\\woff.ttf";
  std::ofstream outfile(outpath, std::ios::out | std::ios::binary);
  outfile.write((const char*)outFileStream.byte, outFileStream.size);
  outfile.flush();
  outfile.close();

  fileStream.release();
//  outFileStream.release();
}