qpdf-compress 0.6.0 → 0.6.2

package/src/encoding_tables.h

@@ -0,0 +1,42 @@
+// shared encoding lookup tables for WinAnsiEncoding and MacRomanEncoding
+#pragma once
+
+#include <cstdint>
+
+// WinAnsiEncoding codes 0x80-0x9F differ from Latin-1/Unicode.
+// All other codes (0x00-0x7F, 0xA0-0xFF) match their Unicode code points.
+inline uint16_t winAnsiToUnicode(uint8_t code) {
+  static const uint16_t table[32] = {
+      0x20AC, 0x0081, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
+      0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x008D, 0x017D, 0x008F,
+      0x0090, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+      0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0x009D, 0x017E, 0x0178,
+  };
+  if (code >= 0x80 && code <= 0x9F)
+    return table[code - 0x80];
+  return code;
+}
+
+// MacRomanEncoding — codes 0x80-0xFF map to various Unicode code points.
+inline uint16_t macRomanToUnicode(uint8_t code) {
+  static const uint16_t table[128] = {
+      0x00C4, 0x00C5, 0x00C7, 0x00C9, 0x00D1, 0x00D6, 0x00DC, 0x00E1, 0x00E0,
+      0x00E2, 0x00E4, 0x00E3, 0x00E5, 0x00E7, 0x00E9, 0x00E8, 0x00EA, 0x00EB,
+      0x00ED, 0x00EC, 0x00EE, 0x00EF, 0x00F1, 0x00F3, 0x00F2, 0x00F4, 0x00F6,
+      0x00F5, 0x00FA, 0x00F9, 0x00FB, 0x00FC, 0x2020, 0x00B0, 0x00A2, 0x00A3,
+      0x00A7, 0x2022, 0x00B6, 0x00DF, 0x00AE, 0x00A9, 0x2122, 0x00B4, 0x00A8,
+      0x2260, 0x00C6, 0x00D8, 0x221E, 0x00B1, 0x2264, 0x2265, 0x00A5, 0x00B5,
+      0x2202, 0x2211, 0x220F, 0x03C0, 0x222B, 0x00AA, 0x00BA, 0x03A9, 0x00E6,
+      0x00F8, 0x00BF, 0x00A1, 0x00AC, 0x221A, 0x0192, 0x2248, 0x2206, 0x00AB,
+      0x00BB, 0x2026, 0x00A0, 0x00C0, 0x00C3, 0x00D5, 0x0152, 0x0153, 0x2013,
+      0x2014, 0x201C, 0x201D, 0x2018, 0x2019, 0x00F7, 0x25CA, 0x00FF, 0x0178,
+      0x2044, 0x20AC, 0x2039, 0x203A, 0xFB01, 0xFB02, 0x2021, 0x00B7, 0x201A,
+      0x201E, 0x2030, 0x00C2, 0x00CA, 0x00C1, 0x00CB, 0x00C8, 0x00CD, 0x00CE,
+      0x00CF, 0x00CC, 0x00D3, 0x00D4, 0xF8FF, 0x00D2, 0x00DA, 0x00DB, 0x00D9,
+      0x0131, 0x02C6, 0x02DC, 0x00AF, 0x02D8, 0x02D9, 0x02DA, 0x00B8, 0x02DD,
+      0x02DB, 0x02C7,
+  };
+  if (code >= 0x80)
+    return table[code - 0x80];
+  return code;
+}

package/src/font_subset.cc

@@ -1,480 +1,183 @@
 #include "font_subset.h"
 
-#include <algorithm>
 #include <cstring>
-#include <map>
-#include <queue>
+#include <string>
+#include <vector>
 
-// ---------------------------------------------------------------------------
-// TrueType binary helpers — big-endian reads
-// ---------------------------------------------------------------------------
-
-static uint16_t readU16(const uint8_t *p) {
-  return static_cast<uint16_t>((p[0] << 8) | p[1]);
-}
-
-static uint32_t readU32(const uint8_t *p) {
-  return (static_cast<uint32_t>(p[0]) << 24) |
-         (static_cast<uint32_t>(p[1]) << 16) |
-         (static_cast<uint32_t>(p[2]) << 8) | p[3];
-}
-
-static int16_t readI16(const uint8_t *p) {
-  return static_cast<int16_t>(readU16(p));
-}
-
-static void writeU16(uint8_t *p, uint16_t v) {
-  p[0] = static_cast<uint8_t>(v >> 8);
-  p[1] = static_cast<uint8_t>(v);
-}
-
-static void writeU32(uint8_t *p, uint32_t v) {
-  p[0] = static_cast<uint8_t>(v >> 24);
-  p[1] = static_cast<uint8_t>(v >> 16);
-  p[2] = static_cast<uint8_t>(v >> 8);
-  p[3] = static_cast<uint8_t>(v);
-}
+#include <hb-subset.h>
+#include <hb.h>
 
 // ---------------------------------------------------------------------------
-// Table directory parsing
+// Glyph lookup using HarfBuzz — replaces manual cmap parsing
 // ---------------------------------------------------------------------------
 
-struct TableRecord {
-  uint32_t tag;
-  uint32_t checksum;
-  uint32_t offset;
-  uint32_t length;
-};
-
-static uint32_t tag(const char *s) {
-  return (static_cast<uint32_t>(s[0]) << 24) |
-         (static_cast<uint32_t>(s[1]) << 16) |
-         (static_cast<uint32_t>(s[2]) << 8) | s[3];
-}
-
-static bool parseTables(const uint8_t *data, size_t size,
-                        std::map<uint32_t, TableRecord> &tables) {
-  if (size < 12)
-    return false;
-
-  uint16_t numTables = readU16(data + 4);
-  if (size < 12 + static_cast<size_t>(numTables) * 16)
-    return false;
-
-  for (uint16_t i = 0; i < numTables; ++i) {
-    const uint8_t *entry = data + 12 + i * 16;
-    TableRecord rec;
-    rec.tag = readU32(entry);
-    rec.checksum = readU32(entry + 4);
-    rec.offset = readU32(entry + 8);
-    rec.length = readU32(entry + 12);
-
-    if (rec.offset + rec.length > size)
-      return false;
-
-    tables[rec.tag] = rec;
-  }
-  return true;
+// helper: create an hb_face from raw font data (HarfBuzz owns a copy)
+static hb_face_t *createFace(const uint8_t *data, size_t size) {
+  hb_blob_t *blob = hb_blob_create(reinterpret_cast<const char *>(data), size,
+                                   HB_MEMORY_MODE_DUPLICATE, nullptr, nullptr);
+  hb_face_t *face = hb_face_create(blob, 0);
+  hb_blob_destroy(blob);
+  return face;
 }
 
-// ---------------------------------------------------------------------------
-// cmap parsing — extract character code → glyph ID mapping
-// ---------------------------------------------------------------------------
-
 std::set<uint16_t> mapCodesToGlyphIds(const uint8_t *data, size_t size,
                                       const std::set<uint16_t> &charCodes) {
   std::set<uint16_t> glyphIds;
   glyphIds.insert(0); // always keep .notdef
 
-  std::map<uint32_t, TableRecord> tables;
-  if (!parseTables(data, size, tables))
-    return glyphIds;
-
-  auto it = tables.find(tag("cmap"));
-  if (it == tables.end())
-    return glyphIds;
-
-  const uint8_t *cmap = data + it->second.offset;
-  size_t cmapLen = it->second.length;
-  if (cmapLen < 4)
+  hb_face_t *face = createFace(data, size);
+  if (hb_face_get_glyph_count(face) == 0) {
+    hb_face_destroy(face);
     return glyphIds;
-
-  uint16_t numSubtables = readU16(cmap + 2);
-
-  // find a suitable subtable (prefer format 4 — the most common)
-  const uint8_t *subtable = nullptr;
-  for (uint16_t i = 0; i < numSubtables; ++i) {
-    if (4 + i * 8 + 8 > cmapLen)
-      break;
-    const uint8_t *entry = cmap + 4 + i * 8;
-    uint32_t subtableOffset = readU32(entry + 4);
-    if (subtableOffset + 2 > cmapLen)
-      continue;
-
-    uint16_t format = readU16(cmap + subtableOffset);
-    if (format == 4) {
-      subtable = cmap + subtableOffset;
-      break;
-    }
   }
 
-  // fallback: use first subtable
-  if (!subtable && numSubtables > 0) {
-    uint32_t subtableOffset = readU32(cmap + 4 + 4);
-    if (subtableOffset + 2 <= cmapLen)
-      subtable = cmap + subtableOffset;
-  }
-
-  if (!subtable)
-    return glyphIds;
-
-  uint16_t format = readU16(subtable);
-
-  if (format == 4) {
-    // format 4: segment mapping to delta values
-    if (subtable + 14 > cmap + cmapLen)
-      return glyphIds;
-
-    uint16_t segCount = readU16(subtable + 6) / 2;
-    const uint8_t *endCodes = subtable + 14;
-    const uint8_t *startCodes =
-        endCodes + segCount * 2 + 2; // +2 for reservedPad
-    const uint8_t *idDeltas = startCodes + segCount * 2;
-    const uint8_t *idRangeOffsets = idDeltas + segCount * 2;
-
-    // bounds check
-    if (idRangeOffsets + segCount * 2 > cmap + cmapLen)
-      return glyphIds;
-
-    for (uint16_t code : charCodes) {
-      for (uint16_t seg = 0; seg < segCount; ++seg) {
-        uint16_t endCode = readU16(endCodes + seg * 2);
-        uint16_t startCode = readU16(startCodes + seg * 2);
-
-        if (code < startCode || code > endCode)
-          continue;
-
-        uint16_t rangeOffset = readU16(idRangeOffsets + seg * 2);
-        uint16_t delta = readU16(idDeltas + seg * 2);
-
-        uint16_t glyphId;
-        if (rangeOffset == 0) {
-          glyphId = static_cast<uint16_t>((code + delta) & 0xFFFF);
-        } else {
-          const uint8_t *glyphIdAddr =
-              idRangeOffsets + seg * 2 + rangeOffset +
-              2 * static_cast<uint16_t>(code - startCode);
-          if (glyphIdAddr + 2 > cmap + cmapLen)
-            break;
-          glyphId = readU16(glyphIdAddr);
-          if (glyphId != 0)
-            glyphId = static_cast<uint16_t>((glyphId + delta) & 0xFFFF);
-        }
-
-        if (glyphId != 0)
-          glyphIds.insert(glyphId);
-        break;
-      }
-    }
-  } else if (format == 0) {
-    // format 0: byte encoding table
-    if (subtable + 6 + 256 > cmap + cmapLen)
-      return glyphIds;
-    for (uint16_t code : charCodes) {
-      if (code < 256) {
-        uint8_t gid = subtable[6 + code];
-        if (gid != 0)
-          glyphIds.insert(gid);
-      }
+  // collect Unicode → GID mapping from ALL cmap subtables (not just the
+  // preferred one). hb_font_get_nominal_glyph only checks the preferred
+  // subtable and can miss glyphs in fonts with multiple cmap encodings.
+  hb_map_t *mapping = hb_map_create();
+  hb_set_t *unicodes = hb_set_create();
+  hb_face_collect_nominal_glyph_mapping(face, mapping, unicodes);
+
+  for (uint16_t code : charCodes) {
+    hb_codepoint_t glyph = hb_map_get(mapping, code);
+    if (glyph != HB_MAP_VALUE_INVALID && glyph != 0)
+      glyphIds.insert(static_cast<uint16_t>(glyph & 0xFFFF));
+
+    // try 0xF000 offset for symbol fonts (Windows Symbol encoding)
+    if ((glyph == HB_MAP_VALUE_INVALID || glyph == 0) && code < 256) {
+      glyph = hb_map_get(mapping, code + 0xF000);
+      if (glyph != HB_MAP_VALUE_INVALID && glyph != 0)
+        glyphIds.insert(static_cast<uint16_t>(glyph & 0xFFFF));
     }
   }
 
+  hb_set_destroy(unicodes);
+  hb_map_destroy(mapping);
+  hb_face_destroy(face);
   return glyphIds;
 }
 
-// ---------------------------------------------------------------------------
-// Collect composite glyph dependencies
-// ---------------------------------------------------------------------------
-
-static void collectCompositeGlyphs(const uint8_t *glyfData, size_t glyfLen,
-                                   const uint8_t *locaData, bool locaLong,
-                                   uint16_t numGlyphs,
-                                   std::set<uint16_t> &glyphIds) {
-  std::queue<uint16_t> toProcess;
-  for (uint16_t gid : glyphIds)
-    toProcess.push(gid);
-
-  while (!toProcess.empty()) {
-    uint16_t gid = toProcess.front();
-    toProcess.pop();
-
-    if (gid >= numGlyphs)
-      continue;
-
-    uint32_t offset, nextOffset;
-    if (locaLong) {
-      offset = readU32(locaData + gid * 4);
-      nextOffset = readU32(locaData + (gid + 1) * 4);
-    } else {
-      offset = static_cast<uint32_t>(readU16(locaData + gid * 2)) * 2;
-      nextOffset = static_cast<uint32_t>(readU16(locaData + (gid + 1) * 2)) * 2;
-    }
-
-    if (offset >= nextOffset || offset >= glyfLen)
-      continue;
-
-    const uint8_t *glyph = glyfData + offset;
-    size_t glyphLen = nextOffset - offset;
-    if (glyphLen < 10)
-      continue;
-
-    int16_t numContours = readI16(glyph);
-    if (numContours >= 0)
-      continue; // simple glyph, no dependencies
-
-    // composite glyph — parse component records
-    size_t pos = 10; // skip header
-    while (pos + 4 <= glyphLen) {
-      uint16_t flags = readU16(glyph + pos);
-      uint16_t componentGid = readU16(glyph + pos + 2);
-      pos += 4;
-
-      if (componentGid < numGlyphs &&
-          glyphIds.find(componentGid) == glyphIds.end()) {
-        glyphIds.insert(componentGid);
-        toProcess.push(componentGid);
-      }
+std::set<uint16_t>
+mapGlyphNamesToGlyphIds(const uint8_t *data, size_t size,
+                        const std::vector<std::string> &names) {
+  std::set<uint16_t> glyphIds;
+  glyphIds.insert(0); // always keep .notdef
 
-      // skip arguments based on flags
-      if (flags & 0x0001) // ARG_1_AND_2_ARE_WORDS
-        pos += 4;
-      else
-        pos += 2;
+  hb_face_t *face = createFace(data, size);
+  if (hb_face_get_glyph_count(face) == 0) {
+    hb_face_destroy(face);
+    return glyphIds;
+  }
 
-      if (flags & 0x0008) // WE_HAVE_A_SCALE
-        pos += 2;
-      else if (flags & 0x0040) // WE_HAVE_AN_X_AND_Y_SCALE
-        pos += 4;
-      else if (flags & 0x0080) // WE_HAVE_A_TWO_BY_TWO
-        pos += 8;
+  hb_font_t *font = hb_font_create(face);
 
-      if (!(flags & 0x0020)) // MORE_COMPONENTS
-        break;
-    }
+  for (const auto &name : names) {
+    hb_codepoint_t glyph = 0;
+    if (hb_font_get_glyph_from_name(font, name.c_str(),
+                                    static_cast<int>(name.size()), &glyph) &&
+        glyph != 0)
+      glyphIds.insert(static_cast<uint16_t>(glyph & 0xFFFF));
   }
+
+  hb_font_destroy(font);
+  hb_face_destroy(face);
+  return glyphIds;
 }
 
 // ---------------------------------------------------------------------------
-// TrueType font subsetting — keep only used glyphs
+// Font subsetting using HarfBuzz hb-subset (TrueType and CFF/OpenType)
 // ---------------------------------------------------------------------------
 
-static uint32_t calcChecksum(const uint8_t *data, size_t length) {
-  uint32_t sum = 0;
-  size_t nLongs = (length + 3) / 4;
-  for (size_t i = 0; i < nLongs; ++i) {
-    uint32_t val = 0;
-    for (size_t j = 0; j < 4; ++j) {
-      size_t idx = i * 4 + j;
-      val = (val << 8) | (idx < length ? data[idx] : 0);
-    }
-    sum += val;
-  }
-  return sum;
+static uint32_t readU32(const uint8_t *p) {
+  return (static_cast<uint32_t>(p[0]) << 24) |
+         (static_cast<uint32_t>(p[1]) << 16) |
+         (static_cast<uint32_t>(p[2]) << 8) | p[3];
 }
 
-bool subsetTrueTypeFont(const uint8_t *data, size_t size,
-                        const std::set<uint16_t> &usedGlyphIds,
-                        std::vector<uint8_t> &output) {
-  std::map<uint32_t, TableRecord> tables;
-  if (!parseTables(data, size, tables))
-    return false;
-
-  // required tables
-  auto headIt = tables.find(tag("head"));
-  auto maxpIt = tables.find(tag("maxp"));
-  auto locaIt = tables.find(tag("loca"));
-  auto glyfIt = tables.find(tag("glyf"));
-
-  if (headIt == tables.end() || maxpIt == tables.end() ||
-      locaIt == tables.end() || glyfIt == tables.end())
+bool subsetFont(const uint8_t *data, size_t size,
+                const std::set<uint16_t> &usedGlyphIds,
+                std::vector<uint8_t> &output, bool preserveCmap) {
+  // validate font header — accept TrueType (0x00010000, 'true') and
+  // OpenType-CFF ('OTTO')
+  if (size < 12)
     return false;
-
-  const uint8_t *headData = data + headIt->second.offset;
-  if (headIt->second.length < 54)
+  uint32_t sfVersion = readU32(data);
+  if (sfVersion != 0x00010000 && sfVersion != 0x74727565 &&
+      sfVersion != 0x4F54544F) // OTTO
     return false;
 
-  bool locaLong = readI16(headData + 50) == 1;
+  // let HarfBuzz own a copy of the font data to avoid any lifetime issues
+  hb_blob_t *blob = hb_blob_create(reinterpret_cast<const char *>(data), size,
+                                   HB_MEMORY_MODE_DUPLICATE, nullptr, nullptr);
+  hb_face_t *face = hb_face_create(blob, 0);
+  hb_blob_destroy(blob);
 
-  const uint8_t *maxpData = data + maxpIt->second.offset;
-  if (maxpIt->second.length < 6)
+  if (hb_face_get_glyph_count(face) == 0) {
+    hb_face_destroy(face);
     return false;
-  uint16_t numGlyphs = readU16(maxpData + 4);
-
-  const uint8_t *locaData = data + locaIt->second.offset;
-  const uint8_t *glyfData = data + glyfIt->second.offset;
-  size_t glyfLen = glyfIt->second.length;
-
-  // collect all needed glyphs including composite dependencies
-  auto allGlyphs = usedGlyphIds;
-  allGlyphs.insert(0); // always keep .notdef
-  collectCompositeGlyphs(glyfData, glyfLen, locaData, locaLong, numGlyphs,
-                         allGlyphs);
-
-  // build new glyf table — map old glyph IDs to new glyph data
-  // we preserve old glyph IDs (don't remap) to keep cmap valid —
-  // instead we zero out unused glyph slots
-  std::vector<uint8_t> newGlyf;
-  std::vector<uint32_t> newLoca(numGlyphs + 1);
-
-  for (uint16_t gid = 0; gid < numGlyphs; ++gid) {
-    newLoca[gid] = static_cast<uint32_t>(newGlyf.size());
-
-    if (allGlyphs.find(gid) == allGlyphs.end())
-      continue; // empty glyph — loca points to same offset as next
-
-    uint32_t offset, nextOffset;
-    if (locaLong) {
-      if ((gid + 1) * 4 + 4 > locaIt->second.length)
-        continue;
-      offset = readU32(locaData + gid * 4);
-      nextOffset = readU32(locaData + (gid + 1) * 4);
-    } else {
-      if ((gid + 1) * 2 + 2 > locaIt->second.length)
-        continue;
-      offset = static_cast<uint32_t>(readU16(locaData + gid * 2)) * 2;
-      nextOffset = static_cast<uint32_t>(readU16(locaData + (gid + 1) * 2)) * 2;
-    }
-
-    if (offset >= nextOffset || offset >= glyfLen)
-      continue;
-
-    uint32_t len =
-        std::min(nextOffset - offset, static_cast<uint32_t>(glyfLen - offset));
-    newGlyf.insert(newGlyf.end(), glyfData + offset, glyfData + offset + len);
-
-    // pad to 2-byte boundary (for short loca) or 4-byte boundary (long loca)
-    size_t align = locaLong ? 4 : 2;
-    while (newGlyf.size() % align != 0)
-      newGlyf.push_back(0);
   }
-  newLoca[numGlyphs] = static_cast<uint32_t>(newGlyf.size());
-
-  // build new loca table
-  std::vector<uint8_t> newLocaData;
-  if (locaLong) {
-    newLocaData.resize((numGlyphs + 1) * 4);
-    for (uint16_t i = 0; i <= numGlyphs; ++i)
-      writeU32(newLocaData.data() + i * 4, newLoca[i]);
-  } else {
-    newLocaData.resize((numGlyphs + 1) * 2);
-    for (uint16_t i = 0; i <= numGlyphs; ++i)
-      writeU16(newLocaData.data() + i * 2,
-               static_cast<uint16_t>(newLoca[i] / 2));
-  }
-
-  // subset hmtx: zero widths for unused glyphs
-  auto hheaIt = tables.find(tag("hhea"));
-  auto hmtxIt = tables.find(tag("hmtx"));
-  std::vector<uint8_t> newHmtx;
-
-  if (hheaIt != tables.end() && hmtxIt != tables.end() &&
-      hheaIt->second.length >= 36) {
-    uint16_t numHMetrics = readU16(data + hheaIt->second.offset + 34);
-    const uint8_t *hmtxData = data + hmtxIt->second.offset;
-    size_t hmtxLen = hmtxIt->second.length;
 
-    newHmtx.assign(hmtxData, hmtxData + hmtxLen);
-
-    for (uint16_t gid = 0; gid < numGlyphs; ++gid) {
-      if (allGlyphs.find(gid) != allGlyphs.end())
-        continue;
-
-      if (gid < numHMetrics) {
-        // long metric entry: advanceWidth(2) + lsb(2)
-        size_t off = static_cast<size_t>(gid) * 4;
-        if (off + 4 <= newHmtx.size()) {
-          writeU16(newHmtx.data() + off, 0);
-          writeU16(newHmtx.data() + off + 2, 0);
-        }
-      } else {
-        // short metric: just lsb(2) after the long entries
-        size_t off = static_cast<size_t>(numHMetrics) * 4 +
-                     static_cast<size_t>(gid - numHMetrics) * 2;
-        if (off + 2 <= newHmtx.size())
-          writeU16(newHmtx.data() + off, 0);
-      }
-    }
+  hb_subset_input_t *input = hb_subset_input_create_or_fail();
+  if (!input) {
+    hb_face_destroy(face);
+    return false;
   }
 
-  // collect tables to write (all original tables, replacing glyf/loca/hmtx)
-  struct OutputTable {
-    uint32_t tag;
-    std::vector<uint8_t> data;
-  };
-  std::vector<OutputTable> outTables;
-
-  for (auto &[tableTag, rec] : tables) {
-    OutputTable ot;
-    ot.tag = tableTag;
-
-    if (tableTag == tag("glyf")) {
-      ot.data = newGlyf;
-    } else if (tableTag == tag("loca")) {
-      ot.data = newLocaData;
-    } else if (tableTag == tag("hmtx") && !newHmtx.empty()) {
-      ot.data = newHmtx;
-    } else {
-      ot.data.assign(data + rec.offset, data + rec.offset + rec.length);
-    }
-
-    outTables.push_back(std::move(ot));
+  // retain original glyph IDs so all existing PDF text references remain
+  // valid — unused glyph slots are zeroed out
+  hb_subset_input_set_flags(input, HB_SUBSET_FLAGS_RETAIN_GIDS);
+
+  // drop font tables unnecessary for PDF rendering
+  hb_set_t *dropTables =
+      hb_subset_input_set(input, HB_SUBSET_SETS_DROP_TABLE_TAG);
+  hb_set_add(dropTables, HB_TAG('G', 'P', 'O', 'S')); // OpenType positioning
+  hb_set_add(dropTables, HB_TAG('G', 'S', 'U', 'B')); // OpenType substitution
+  hb_set_add(dropTables, HB_TAG('G', 'D', 'E', 'F')); // OpenType definitions
+  hb_set_add(dropTables, HB_TAG('D', 'S', 'I', 'G')); // digital signature
+  hb_set_add(dropTables, HB_TAG('k', 'e', 'r', 'n')); // legacy kerning
+  hb_set_add(dropTables, HB_TAG('n', 'a', 'm', 'e')); // font naming strings
+  hb_set_add(dropTables, HB_TAG('g', 'a', 's', 'p')); // grid-fitting hints
+  hb_set_add(dropTables,
+             HB_TAG('h', 'd', 'm', 'x')); // horizontal device metrics
+  hb_set_add(dropTables, HB_TAG('L', 'T', 'S', 'H')); // linear threshold
+  hb_set_add(dropTables, HB_TAG('V', 'D', 'M', 'X')); // device metrics
+
+  // preserve the cmap table unchanged for simple TrueType fonts —
+  // PDF viewers use it to resolve character codes to glyph IDs.
+  // for CID fonts, PDF viewers use /CIDToGIDMap instead, so the cmap
+  // can be freely subset.
+  if (preserveCmap) {
+    hb_set_t *noSubsetTables =
+        hb_subset_input_set(input, HB_SUBSET_SETS_NO_SUBSET_TABLE_TAG);
+    hb_set_add(noSubsetTables, HB_TAG('c', 'm', 'a', 'p'));
   }
 
-  // sort by tag (recommended for efficient access)
-  std::sort(
-      outTables.begin(), outTables.end(),
-      [](const OutputTable &a, const OutputTable &b) { return a.tag < b.tag; });
+  // populate the glyph set to keep
+  hb_set_t *glyphs = hb_subset_input_glyph_set(input);
+  for (uint16_t gid : usedGlyphIds)
+    hb_set_add(glyphs, gid);
 
-  // calculate output size
-  uint16_t numOutTables = static_cast<uint16_t>(outTables.size());
-  size_t headerSize = 12 + numOutTables * 16;
-  size_t totalSize = headerSize;
-  for (auto &ot : outTables)
-    totalSize += ((ot.data.size() + 3) / 4) * 4; // pad to 4 bytes
+  hb_face_t *subset = hb_subset_or_fail(face, input);
+  hb_subset_input_destroy(input);
+  hb_face_destroy(face);
 
-  output.resize(totalSize, 0);
-  uint8_t *out = output.data();
+  if (!subset)
+    return false;
 
-  // write offset table
-  writeU32(out, readU32(data)); // sfVersion (same as original)
-  writeU16(out + 4, numOutTables);
+  hb_blob_t *result = hb_face_reference_blob(subset);
+  unsigned int length = 0;
+  const char *resultData = hb_blob_get_data(result, &length);
 
-  // searchRange, entrySelector, rangeShift
-  uint16_t searchRange = 1;
-  uint16_t entrySelector = 0;
-  while (searchRange * 2 <= numOutTables) {
-    searchRange *= 2;
-    ++entrySelector;
+  if (length == 0 || !resultData) {
+    hb_blob_destroy(result);
+    hb_face_destroy(subset);
+    return false;
   }
-  searchRange *= 16;
-  writeU16(out + 6, searchRange);
-  writeU16(out + 8, entrySelector);
-  writeU16(out + 10, numOutTables * 16 - searchRange);
 
-  // write table records and data
-  size_t dataOffset = headerSize;
-  for (uint16_t i = 0; i < numOutTables; ++i) {
-    auto &ot = outTables[i];
-    uint8_t *rec = out + 12 + i * 16;
-
-    writeU32(rec, ot.tag);
-    writeU32(rec + 4, calcChecksum(ot.data.data(), ot.data.size()));
-    writeU32(rec + 8, static_cast<uint32_t>(dataOffset));
-    writeU32(rec + 12, static_cast<uint32_t>(ot.data.size()));
-
-    memcpy(out + dataOffset, ot.data.data(), ot.data.size());
-    dataOffset += ((ot.data.size() + 3) / 4) * 4;
-  }
+  output.assign(reinterpret_cast<const uint8_t *>(resultData),
+                reinterpret_cast<const uint8_t *>(resultData) + length);
 
+  hb_blob_destroy(result);
+  hb_face_destroy(subset);
   return true;
 }