qpdf-compress 0.6.0 → 0.6.2

package/src/fonts.cc

@@ -0,0 +1,1209 @@
+#include "fonts.h"
+#include "encoding_tables.h"
+#include "font_subset.h"
+
+#include <algorithm>
+#include <cstdint>
+#include <map>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <qpdf/QPDFObjectHandle.hh>
+#include <qpdf/QPDFPageDocumentHelper.hh>
+#include <qpdf/QPDFPageObjectHelper.hh>
+
+namespace {
+
+/// Checks if a font BaseFont name has a subset prefix (e.g., "ABCDEF+ArialMT").
+bool isAlreadySubset(QPDFObjectHandle fontObj) {
+  auto baseFont = fontObj.getKey("/BaseFont");
+  if (!baseFont.isName())
+    return false;
+  auto name = baseFont.getName();
+  if (!name.empty() && name[0] == '/')
+    name = name.substr(1);
+  if (name.size() <= 7 || name[6] != '+')
+    return false;
+  for (int i = 0; i < 6; ++i) {
+    if (name[i] < 'A' || name[i] > 'Z')
+      return false;
+  }
+  return true;
+}
+
+} // namespace
+
+// ---------------------------------------------------------------------------
+// Combined parser callback: collects font names referenced by Tf operators
+// AND character codes used by each font in a single pass
+// ---------------------------------------------------------------------------
+
+class FontUsageCollector : public QPDFObjectHandle::ParserCallbacks {
+public:
+  std::map<std::string, std::set<uint16_t>> fontCodes;
+  std::set<std::string> cidFonts; // set before parsing
+
+  void handleObject(QPDFObjectHandle obj) override {
+    if (obj.isOperator()) {
+      std::string op = obj.getOperatorValue();
+      if (op == "Tf" && operands.size() >= 2) {
+        auto nameObj = operands[operands.size() - 2];
+        if (nameObj.isName()) {
+          currentFont = nameObj.getName();
+        }
+      }
+      if (!currentFont.empty()) {
+        bool isCID = cidFonts.count(currentFont) > 0;
+        if (op == "Tj" || op == "'" || op == "\"") {
+          if (!operands.empty() && operands.back().isString())
+            collectFromString(operands.back(), isCID);
+        } else if (op == "TJ") {
+          if (!operands.empty() && operands.back().isArray()) {
+            auto arr = operands.back();
+            for (int i = 0; i < arr.getArrayNItems(); ++i) {
+              auto item = arr.getArrayItem(i);
+              if (item.isString())
+                collectFromString(item, isCID);
+            }
+          }
+        }
+      }
+      operands.clear();
+    } else {
+      operands.push_back(obj);
+    }
+  }
+  void handleEOF() override {}
+
+private:
+  std::string currentFont;
+  std::vector<QPDFObjectHandle> operands;
+
+  void collectFromString(QPDFObjectHandle strObj, bool isCID) {
+    std::string raw = strObj.getStringValue();
+    if (isCID) {
+      for (size_t i = 0; i + 1 < raw.size(); i += 2) {
+        uint16_t code = (static_cast<uint8_t>(raw[i]) << 8) |
+                        static_cast<uint8_t>(raw[i + 1]);
+        fontCodes[currentFont].insert(code);
+      }
+    } else {
+      for (unsigned char c : raw)
+        fontCodes[currentFont].insert(c);
+    }
+  }
+};
+
+// helper: run FontUsageCollector on a stream, swallowing parse errors
+static void collectFontUsageFromStream(QPDFObjectHandle stream,
+                                       FontUsageCollector &collector) {
+  try {
+    QPDFObjectHandle::parseContentStream(stream, &collector);
+  } catch (...) {
+  }
+}
+
+// ---------------------------------------------------------------------------
+// /ToUnicode CMap parser — converts character codes to Unicode using the
+// font's /ToUnicode stream. handles beginbfchar, beginbfrange (scalar and
+// array forms). this is the most reliable way to map codes to Unicode.
+// ---------------------------------------------------------------------------
+
+static std::set<uint16_t> parseToUnicode(QPDFObjectHandle toUnicodeStream,
+                                         const std::set<uint16_t> &charCodes) {
+  std::set<uint16_t> unicodeCodes;
+
+  try {
+    auto data = toUnicodeStream.getStreamData(qpdf_dl_all);
+    std::string cmap(reinterpret_cast<const char *>(data->getBuffer()),
+                     data->getSize());
+
+    // helper: find <hex> value at/after pos, return parsed value and position
+    // after closing >
+    auto findHexValue = [&](size_t pos,
+                            size_t end) -> std::pair<uint16_t, size_t> {
+      size_t start = cmap.find('<', pos);
+      if (start == std::string::npos || start >= end)
+        return {0, std::string::npos};
+      size_t stop = cmap.find('>', start);
+      if (stop == std::string::npos || stop >= end)
+        return {0, std::string::npos};
+      std::string hex = cmap.substr(start + 1, stop - start - 1);
+      if (hex.empty())
+        return {0, stop + 1};
+      return {static_cast<uint16_t>(std::stoul(hex, nullptr, 16)), stop + 1};
+    };
+
+    // process beginbfchar sections: <srcCode> <dstUnicode>
+    size_t pos = 0;
+    while (true) {
+      size_t start = cmap.find("beginbfchar", pos);
+      if (start == std::string::npos)
+        break;
+      start += 11;
+      size_t end = cmap.find("endbfchar", start);
+      if (end == std::string::npos)
+        break;
+
+      size_t p = start;
+      while (p < end) {
+        auto [src, after1] = findHexValue(p, end);
+        if (after1 == std::string::npos)
+          break;
+        auto [dst, after2] = findHexValue(after1, end);
+        if (after2 == std::string::npos)
+          break;
+        if (charCodes.count(src))
+          unicodeCodes.insert(dst);
+        p = after2;
+      }
+      pos = end + 9;
+    }
+
+    // process beginbfrange sections: <lo> <hi> <dstStart> or <lo> <hi> [...]
+    pos = 0;
+    while (true) {
+      size_t start = cmap.find("beginbfrange", pos);
+      if (start == std::string::npos)
+        break;
+      start += 12;
+      size_t end = cmap.find("endbfrange", start);
+      if (end == std::string::npos)
+        break;
+
+      size_t p = start;
+      while (p < end) {
+        auto [lo, after1] = findHexValue(p, end);
+        if (after1 == std::string::npos)
+          break;
+        auto [hi, after2] = findHexValue(after1, end);
+        if (after2 == std::string::npos)
+          break;
+
+        // check for array form vs scalar form
+        size_t next = after2;
+        while (next < end &&
+               std::isspace(static_cast<unsigned char>(cmap[next])))
+          ++next;
+
+        if (next < end && cmap[next] == '[') {
+          // array form: <lo> <hi> [<v1> <v2> ...]
+          size_t arrEnd = cmap.find(']', next);
+          if (arrEnd == std::string::npos || arrEnd >= end)
+            break;
+          uint16_t code = lo;
+          size_t ap = next + 1;
+          while (ap < arrEnd && code <= hi) {
+            auto [val, afterVal] = findHexValue(ap, arrEnd);
+            if (afterVal == std::string::npos)
+              break;
+            if (charCodes.count(code))
+              unicodeCodes.insert(val);
+            ++code;
+            ap = afterVal;
+          }
+          p = arrEnd + 1;
+        } else {
+          // scalar form: <lo> <hi> <dstStart>
+          auto [dstStart, after3] = findHexValue(after2, end);
+          if (after3 == std::string::npos)
+            break;
+          for (uint16_t c = lo; c <= hi; ++c) {
+            if (charCodes.count(c))
+              unicodeCodes.insert(static_cast<uint16_t>(dstStart + (c - lo)));
+          }
+          p = after3;
+        }
+      }
+      pos = end + 10;
+    }
+  } catch (...) {
+    // parsing failed — return what we have so far
+  }
+
+  return unicodeCodes;
+}
+
+// ---------------------------------------------------------------------------
+// /Encoding /Differences parser — extract glyph names for character codes
+// that have been remapped via /Differences entries.
+// format: [code1 /name1 /name2 ... code2 /name3 ...]
+// integers set current position; names are assigned sequentially.
+// ---------------------------------------------------------------------------
+
+static std::vector<std::string>
+getGlyphNamesFromEncoding(const std::set<uint16_t> &codes,
+                          QPDFObjectHandle fontObj) {
+  std::vector<std::string> names;
+
+  auto encoding = fontObj.getKey("/Encoding");
+  if (!encoding.isDictionary())
+    return names;
+
+  auto diffs = encoding.getKey("/Differences");
+  if (!diffs.isArray())
+    return names;
+
+  // parse /Differences: integers set position, names are glyph names
+  std::map<uint16_t, std::string> codeToName;
+  int currentCode = 0;
+  for (int i = 0; i < diffs.getArrayNItems(); ++i) {
+    auto item = diffs.getArrayItem(i);
+    if (item.isInteger()) {
+      currentCode = static_cast<int>(item.getIntValue());
+    } else if (item.isName()) {
+      std::string name = item.getName();
+      // strip leading / from PDF name
+      if (!name.empty() && name[0] == '/')
+        name = name.substr(1);
+      codeToName[static_cast<uint16_t>(currentCode)] = name;
+      ++currentCode;
+    }
+  }
+
+  // return glyph names for used codes that have /Differences entries
+  for (uint16_t code : codes) {
+    auto it = codeToName.find(code);
+    if (it != codeToName.end())
+      names.push_back(it->second);
+  }
+
+  return names;
+}
+
+// ---------------------------------------------------------------------------
+// Encoding helpers — convert encoding-specific byte codes to Unicode
+// for correct cmap lookups during font subsetting
+// ---------------------------------------------------------------------------
+
+// convert Adobe Glyph List (AGL) name to Unicode codepoint. handles:
+// - "uniXXXX" convention (4 hex digits after "uni")
+// - "uXXXX"/"uXXXXX" convention (4-6 hex digits after "u")
+// - standard AGL names for common Latin/currency/typographic characters
+static uint16_t glyphNameToUnicode(const std::string &name) {
+  // strip any variant suffix (e.g., "Euro.oldstyle" → "Euro")
+  std::string base = name;
+  auto dot = base.find('.');
+  if (dot != std::string::npos)
+    base = base.substr(0, dot);
+
+  // "uniXXXX" — standard Unicode naming convention
+  if (base.size() == 7 && base[0] == 'u' && base[1] == 'n' && base[2] == 'i') {
+    char *end = nullptr;
+    unsigned long val = strtoul(base.c_str() + 3, &end, 16);
+    if (end == base.c_str() + 7 && val > 0 && val <= 0xFFFF)
+      return static_cast<uint16_t>(val);
+  }
+
+  // "uXXXX" or "uXXXXX" — alternate Unicode naming convention
+  if (base.size() >= 5 && base.size() <= 7 && base[0] == 'u' &&
+      base[1] != 'n') {
+    char *end = nullptr;
+    unsigned long val = strtoul(base.c_str() + 1, &end, 16);
+    if (end == base.c_str() + static_cast<ptrdiff_t>(base.size()) && val > 0 &&
+        val <= 0xFFFF)
+      return static_cast<uint16_t>(val);
+  }
+
+  // single-character names map to their ASCII value
+  if (base.size() == 1 && base[0] >= 0x20)
+    return static_cast<uint16_t>(static_cast<unsigned char>(base[0]));
+
+  // standard AGL names — covers WinAnsi, Latin Extended, and common symbols
+  // sourced from the Adobe Glyph List (agl-aglfn) specification
+  static const std::map<std::string, uint16_t> agl = {
+      // basic ASCII names
+      {"space", 0x0020},
+      {"exclam", 0x0021},
+      {"quotedbl", 0x0022},
+      {"numbersign", 0x0023},
+      {"dollar", 0x0024},
+      {"percent", 0x0025},
+      {"ampersand", 0x0026},
+      {"quotesingle", 0x0027},
+      {"parenleft", 0x0028},
+      {"parenright", 0x0029},
+      {"asterisk", 0x002A},
+      {"plus", 0x002B},
+      {"comma", 0x002C},
+      {"hyphen", 0x002D},
+      {"period", 0x002E},
+      {"slash", 0x002F},
+      {"zero", 0x0030},
+      {"one", 0x0031},
+      {"two", 0x0032},
+      {"three", 0x0033},
+      {"four", 0x0034},
+      {"five", 0x0035},
+      {"six", 0x0036},
+      {"seven", 0x0037},
+      {"eight", 0x0038},
+      {"nine", 0x0039},
+      {"colon", 0x003A},
+      {"semicolon", 0x003B},
+      {"less", 0x003C},
+      {"equal", 0x003D},
+      {"greater", 0x003E},
+      {"question", 0x003F},
+      {"at", 0x0040},
+      {"bracketleft", 0x005B},
+      {"backslash", 0x005C},
+      {"bracketright", 0x005D},
+      {"asciicircum", 0x005E},
+      {"underscore", 0x005F},
+      {"grave", 0x0060},
+      {"braceleft", 0x007B},
+      {"bar", 0x007C},
+      {"braceright", 0x007D},
+      {"asciitilde", 0x007E},
+      // WinAnsi 0x80-0x9F range
+      {"Euro", 0x20AC},
+      {"quotesinglbase", 0x201A},
+      {"florin", 0x0192},
+      {"quotedblbase", 0x201E},
+      {"ellipsis", 0x2026},
+      {"dagger", 0x2020},
+      {"daggerdbl", 0x2021},
+      {"circumflex", 0x02C6},
+      {"perthousand", 0x2030},
+      {"Scaron", 0x0160},
+      {"guilsinglleft", 0x2039},
+      {"OE", 0x0152},
+      {"Zcaron", 0x017D},
+      {"quoteleft", 0x2018},
+      {"quoteright", 0x2019},
+      {"quotedblleft", 0x201C},
+      {"quotedblright", 0x201D},
+      {"bullet", 0x2022},
+      {"endash", 0x2013},
+      {"emdash", 0x2014},
+      {"tilde", 0x02DC},
+      {"trademark", 0x2122},
+      {"scaron", 0x0161},
+      {"guilsinglright", 0x203A},
+      {"oe", 0x0153},
+      {"zcaron", 0x017E},
+      {"Ydieresis", 0x0178},
+      // Latin-1 Supplement (0xA0-0xFF)
+      {"nbspace", 0x00A0},
+      {"exclamdown", 0x00A1},
+      {"cent", 0x00A2},
+      {"sterling", 0x00A3},
+      {"currency", 0x00A4},
+      {"yen", 0x00A5},
+      {"brokenbar", 0x00A6},
+      {"section", 0x00A7},
+      {"dieresis", 0x00A8},
+      {"copyright", 0x00A9},
+      {"ordfeminine", 0x00AA},
+      {"guillemotleft", 0x00AB},
+      {"logicalnot", 0x00AC},
+      {"softhyphen", 0x00AD},
+      {"registered", 0x00AE},
+      {"macron", 0x00AF},
+      {"degree", 0x00B0},
+      {"plusminus", 0x00B1},
+      {"twosuperior", 0x00B2},
+      {"threesuperior", 0x00B3},
+      {"acute", 0x00B4},
+      {"mu", 0x00B5},
+      {"paragraph", 0x00B6},
+      {"periodcentered", 0x00B7},
+      {"cedilla", 0x00B8},
+      {"onesuperior", 0x00B9},
+      {"ordmasculine", 0x00BA},
+      {"guillemotright", 0x00BB},
+      {"onequarter", 0x00BC},
+      {"onehalf", 0x00BD},
+      {"threequarters", 0x00BE},
+      {"questiondown", 0x00BF},
+      {"Agrave", 0x00C0},
+      {"Aacute", 0x00C1},
+      {"Acircumflex", 0x00C2},
+      {"Atilde", 0x00C3},
+      {"Adieresis", 0x00C4},
+      {"Aring", 0x00C5},
+      {"AE", 0x00C6},
+      {"Ccedilla", 0x00C7},
+      {"Egrave", 0x00C8},
+      {"Eacute", 0x00C9},
+      {"Ecircumflex", 0x00CA},
+      {"Edieresis", 0x00CB},
+      {"Igrave", 0x00CC},
+      {"Iacute", 0x00CD},
+      {"Icircumflex", 0x00CE},
+      {"Idieresis", 0x00CF},
+      {"Eth", 0x00D0},
+      {"Ntilde", 0x00D1},
+      {"Ograve", 0x00D2},
+      {"Oacute", 0x00D3},
+      {"Ocircumflex", 0x00D4},
+      {"Otilde", 0x00D5},
+      {"Odieresis", 0x00D6},
+      {"multiply", 0x00D7},
+      {"Oslash", 0x00D8},
+      {"Ugrave", 0x00D9},
+      {"Uacute", 0x00DA},
+      {"Ucircumflex", 0x00DB},
+      {"Udieresis", 0x00DC},
+      {"Yacute", 0x00DD},
+      {"Thorn", 0x00DE},
+      {"germandbls", 0x00DF},
+      {"agrave", 0x00E0},
+      {"aacute", 0x00E1},
+      {"acircumflex", 0x00E2},
+      {"atilde", 0x00E3},
+      {"adieresis", 0x00E4},
+      {"aring", 0x00E5},
+      {"ae", 0x00E6},
+      {"ccedilla", 0x00E7},
+      {"egrave", 0x00E8},
+      {"eacute", 0x00E9},
+      {"ecircumflex", 0x00EA},
+      {"edieresis", 0x00EB},
+      {"igrave", 0x00EC},
+      {"iacute", 0x00ED},
+      {"icircumflex", 0x00EE},
+      {"idieresis", 0x00EF},
+      {"eth", 0x00F0},
+      {"ntilde", 0x00F1},
+      {"ograve", 0x00F2},
+      {"oacute", 0x00F3},
+      {"ocircumflex", 0x00F4},
+      {"otilde", 0x00F5},
+      {"odieresis", 0x00F6},
+      {"divide", 0x00F7},
+      {"oslash", 0x00F8},
+      {"ugrave", 0x00F9},
+      {"uacute", 0x00FA},
+      {"ucircumflex", 0x00FB},
+      {"udieresis", 0x00FC},
+      {"yacute", 0x00FD},
+      {"thorn", 0x00FE},
+      {"ydieresis", 0x00FF},
+      // Latin Extended-A (commonly found in CE font /Differences)
+      {"Amacron", 0x0100},
+      {"amacron", 0x0101},
+      {"Abreve", 0x0102},
+      {"abreve", 0x0103},
+      {"Aogonek", 0x0104},
+      {"aogonek", 0x0105},
+      {"Cacute", 0x0106},
+      {"cacute", 0x0107},
+      {"Ccircumflex", 0x0108},
+      {"ccircumflex", 0x0109},
+      {"Cdotaccent", 0x010A},
+      {"cdotaccent", 0x010B},
+      {"Ccaron", 0x010C},
+      {"ccaron", 0x010D},
+      {"Dcaron", 0x010E},
+      {"dcaron", 0x010F},
+      {"Dcroat", 0x0110},
+      {"dcroat", 0x0111},
+      {"Emacron", 0x0112},
+      {"emacron", 0x0113},
+      {"Ebreve", 0x0114},
+      {"ebreve", 0x0115},
+      {"Edotaccent", 0x0116},
+      {"edotaccent", 0x0117},
+      {"Eogonek", 0x0118},
+      {"eogonek", 0x0119},
+      {"Ecaron", 0x011A},
+      {"ecaron", 0x011B},
+      {"Gbreve", 0x011E},
+      {"gbreve", 0x011F},
+      {"Gdotaccent", 0x0120},
+      {"gdotaccent", 0x0121},
+      {"Gcommaaccent", 0x0122},
+      {"gcommaaccent", 0x0123},
+      {"Idotaccent", 0x0130},
+      {"dotlessi", 0x0131},
+      {"IJ", 0x0132},
+      {"ij", 0x0133},
+      {"Lacute", 0x0139},
+      {"lacute", 0x013A},
+      {"Lcommaaccent", 0x013B},
+      {"lcommaaccent", 0x013C},
+      {"Lcaron", 0x013D},
+      {"lcaron", 0x013E},
+      {"Ldot", 0x013F},
+      {"ldot", 0x0140},
+      {"Lslash", 0x0141},
+      {"lslash", 0x0142},
+      {"Nacute", 0x0143},
+      {"nacute", 0x0144},
+      {"Ncommaaccent", 0x0145},
+      {"ncommaaccent", 0x0146},
+      {"Ncaron", 0x0147},
+      {"ncaron", 0x0148},
+      {"Eng", 0x014A},
+      {"eng", 0x014B},
+      {"Omacron", 0x014C},
+      {"omacron", 0x014D},
+      {"Obreve", 0x014E},
+      {"obreve", 0x014F},
+      {"Ohungarumlaut", 0x0150},
+      {"ohungarumlaut", 0x0151},
+      {"Racute", 0x0154},
+      {"racute", 0x0155},
+      {"Rcommaaccent", 0x0156},
+      {"rcommaaccent", 0x0157},
+      {"Rcaron", 0x0158},
+      {"rcaron", 0x0159},
+      {"Sacute", 0x015A},
+      {"sacute", 0x015B},
+      {"Scircumflex", 0x015C},
+      {"scircumflex", 0x015D},
+      {"Scedilla", 0x015E},
+      {"scedilla", 0x015F},
+      {"Tcaron", 0x0164},
+      {"tcaron", 0x0165},
+      {"Tbar", 0x0166},
+      {"tbar", 0x0167},
+      {"Umacron", 0x016A},
+      {"umacron", 0x016B},
+      {"Ubreve", 0x016C},
+      {"ubreve", 0x016D},
+      {"Uring", 0x016E},
+      {"uring", 0x016F},
+      {"Uhungarumlaut", 0x0170},
+      {"uhungarumlaut", 0x0171},
+      {"Uogonek", 0x0172},
+      {"uogonek", 0x0173},
+      {"Zacute", 0x0179},
+      {"zacute", 0x017A},
+      {"Zdotaccent", 0x017B},
+      {"zdotaccent", 0x017C},
+      // common currency symbols
+      {"colonmonetary", 0x20A1},
+      {"franc", 0x20A3},
+      {"lira", 0x20A4},
+      {"peseta", 0x20A7},
+      {"won", 0x20A9},
+      {"dong", 0x20AB},
+      // typographic symbols
+      {"fi", 0xFB01},
+      {"fl", 0xFB02},
+      {"minus", 0x2212},
+      {"fraction", 0x2044},
+  };
+
+  auto it = agl.find(base);
+  if (it != agl.end())
+    return it->second;
+  return 0;
+}
+
+// parse /Encoding /Differences to build a map of code → glyph name.
+// used to identify which codes are remapped by /Differences.
+static std::map<uint16_t, std::string>
+getDifferencesCodeMap(QPDFObjectHandle fontObj) {
+  std::map<uint16_t, std::string> codeToName;
+
+  auto encoding = fontObj.getKey("/Encoding");
+  if (!encoding.isDictionary())
+    return codeToName;
+
+  auto diffs = encoding.getKey("/Differences");
+  if (!diffs.isArray())
+    return codeToName;
+
+  int currentCode = 0;
+  for (int i = 0; i < diffs.getArrayNItems(); ++i) {
+    auto item = diffs.getArrayItem(i);
+    if (item.isInteger()) {
+      currentCode = static_cast<int>(item.getIntValue());
+    } else if (item.isName()) {
+      std::string name = item.getName();
+      if (!name.empty() && name[0] == '/')
+        name = name.substr(1);
+      codeToName[static_cast<uint16_t>(currentCode)] = name;
+      ++currentCode;
+    }
+  }
+  return codeToName;
+}
+
+// convert encoding-specific character codes to Unicode for cmap lookup
+static std::set<uint16_t> convertCodesToUnicode(const std::set<uint16_t> &codes,
+                                                QPDFObjectHandle fontObj) {
+  auto encoding = fontObj.getKey("/Encoding");
+
+  bool isWinAnsi = false;
+  bool isMacRoman = false;
+  if (encoding.isName()) {
+    if (encoding.getName() == "/WinAnsiEncoding")
+      isWinAnsi = true;
+    else if (encoding.getName() == "/MacRomanEncoding")
+      isMacRoman = true;
+  } else if (encoding.isDictionary()) {
+    auto baseEnc = encoding.getKey("/BaseEncoding");
+    if (baseEnc.isName()) {
+      if (baseEnc.getName() == "/WinAnsiEncoding")
+        isWinAnsi = true;
+      else if (baseEnc.getName() == "/MacRomanEncoding")
+        isMacRoman = true;
+    }
+  }
+
+  if (!isWinAnsi && !isMacRoman)
+    return codes;
+
+  std::set<uint16_t> unicodeCodes;
+  for (uint16_t code : codes) {
+    if (isWinAnsi)
+      unicodeCodes.insert(winAnsiToUnicode(static_cast<uint8_t>(code)));
+    else
+      unicodeCodes.insert(macRomanToUnicode(static_cast<uint8_t>(code)));
+  }
+  return unicodeCodes;
+}
+
+// ---------------------------------------------------------------------------
+// Combined font optimization — remove unused fonts AND subset remaining
+// fonts in a single page walk
+// ---------------------------------------------------------------------------
+
+void optimizeFonts(QPDF &qpdf) {
+  // single page walk: collect used font names + character codes per font
+  std::map<QPDFObjGen, std::set<uint16_t>> fontUsedCodes;
+
+  for (auto &page : QPDFPageDocumentHelper(qpdf).getAllPages()) {
+    auto pageObj = page.getObjectHandle();
+    auto resources = pageObj.getKey("/Resources");
+    if (!resources.isDictionary())
+      continue;
+    auto fonts = resources.getKey("/Font");
+    if (!fonts.isDictionary())
+      continue;
+
+    // build list of (stream, fontDict) pairs to scan
+    struct StreamFonts {
+      QPDFObjectHandle stream;
+      QPDFObjectHandle fontDict;
+    };
+    std::vector<StreamFonts> scanTargets;
+
+    try {
+      auto contents = pageObj.getKey("/Contents");
+      scanTargets.push_back({contents, fonts});
+    } catch (...) {
+      continue;
+    }
+
+    auto xobjects = resources.getKey("/XObject");
+    if (xobjects.isDictionary()) {
+      // recursively scan Form XObjects (queue-based to handle nesting)
+      std::vector<QPDFObjectHandle> xobjQueue;
+      std::set<QPDFObjGen> visitedXObjects;
+      for (auto &xobjKey : xobjects.getKeys())
+        xobjQueue.push_back(xobjects.getKey(xobjKey));
+
+      while (!xobjQueue.empty()) {
+        auto xobj = xobjQueue.back();
+        xobjQueue.pop_back();
+        if (!xobj.isStream())
+          continue;
+        auto xobjOg = xobj.getObjGen();
+        if (visitedXObjects.count(xobjOg))
+          continue;
+        visitedXObjects.insert(xobjOg);
+
+        auto xobjDict = xobj.getDict();
+        auto xobjSubtype = xobjDict.getKey("/Subtype");
+        if (!xobjSubtype.isName() || xobjSubtype.getName() != "/Form")
+          continue;
+
+        auto xobjRes = xobjDict.getKey("/Resources");
+        if (xobjRes.isDictionary() && xobjRes.getKey("/Font").isDictionary())
+          scanTargets.push_back({xobj, xobjRes.getKey("/Font")});
+        else
+          scanTargets.push_back({xobj, fonts});
+
+        // queue nested XObjects for recursive scanning
+        if (xobjRes.isDictionary()) {
+          auto nestedXObjects = xobjRes.getKey("/XObject");
+          if (nestedXObjects.isDictionary()) {
+            for (auto &nestedKey : nestedXObjects.getKeys())
+              xobjQueue.push_back(nestedXObjects.getKey(nestedKey));
+          }
+        }
+      }
+    }
+
+    // determine which fonts are CID for the collector
+    FontUsageCollector collector;
+    for (auto &target : scanTargets) {
+      for (auto &key : target.fontDict.getKeys()) {
+        auto fontObj = target.fontDict.getKey(key);
+        if (!fontObj.isDictionary())
+          continue;
+        auto subtypeKey = fontObj.getKey("/Subtype");
+        if (subtypeKey.isName() && subtypeKey.getName() == "/Type0")
+          collector.cidFonts.insert(key);
+      }
+    }
+
+    // parse all content streams for this page in one pass per stream
+    for (auto &target : scanTargets)
+      collectFontUsageFromStream(target.stream, collector);
+
+    // map per-name codes to per-ObjGen codes for subsetting
+    for (auto &target : scanTargets) {
+      for (auto &key : target.fontDict.getKeys()) {
+        auto it = collector.fontCodes.find(key);
+        if (it == collector.fontCodes.end())
+          continue;
+        auto fontObj = target.fontDict.getKey(key);
+        if (!fontObj.isDictionary())
+          continue;
+        auto og = fontObj.getObjGen();
+        fontUsedCodes[og].insert(it->second.begin(), it->second.end());
+      }
+    }
+  }
+
+  // for each font with a /Widths array, zero out widths for unused glyphs
+  // and truncate trailing zeros
+  for (auto &[og, usedCodes] : fontUsedCodes) {
+    auto fontObj = qpdf.getObjectByObjGen(og);
+    if (!fontObj.isDictionary())
+      continue;
+
+    auto subtype = fontObj.getKey("/Subtype");
+    if (!subtype.isName())
+      continue;
+
+    // only handle simple fonts with /Widths arrays (TrueType, Type1)
+    if (subtype.getName() != "/TrueType" && subtype.getName() != "/Type1")
+      continue;
+
+    // skip already-subset fonts — their encodings are custom and our usage
+    // collector may miscount character codes
+    if (isAlreadySubset(fontObj))
+      continue;
+
+    auto widths = fontObj.getKey("/Widths");
+    auto firstCharObj = fontObj.getKey("/FirstChar");
+    if (!widths.isArray() || !firstCharObj.isInteger())
+      continue;
+
+    int firstChar = static_cast<int>(firstCharObj.getIntValue());
+    int widthCount = widths.getArrayNItems();
+
+    // zero out widths for unused character codes
+    bool modified = false;
+    for (int i = 0; i < widthCount; ++i) {
+      int charCode = firstChar + i;
+      if (usedCodes.find(static_cast<uint16_t>(charCode)) == usedCodes.end()) {
+        auto w = widths.getArrayItem(i);
+        if (w.isInteger() && w.getIntValue() != 0) {
+          widths.setArrayItem(i, QPDFObjectHandle::newInteger(0));
+          modified = true;
+        } else if (w.isReal() && w.getNumericValue() != 0.0) {
+          widths.setArrayItem(i, QPDFObjectHandle::newInteger(0));
+          modified = true;
+        }
+      }
+    }
+    if (!modified)
+      continue;
+
+    // trim trailing zero-width entries and adjust /LastChar
+    int lastUsed = widthCount - 1;
+    while (lastUsed >= 0) {
+      auto w = widths.getArrayItem(lastUsed);
+      if (w.isInteger() && w.getIntValue() == 0)
+        --lastUsed;
+      else
+        break;
+    }
+
+    if (lastUsed < widthCount - 1) {
+      // rebuild the widths array with only the needed entries
+      auto newWidths = QPDFObjectHandle::newArray();
+      for (int i = 0; i <= lastUsed; ++i)
+        newWidths.appendItem(widths.getArrayItem(i));
+
+      fontObj.replaceKey("/Widths", newWidths);
+      fontObj.replaceKey("/LastChar",
+                         QPDFObjectHandle::newInteger(firstChar + lastUsed));
+    }
+  }
+
+  // true font subsetting: strip unused glyph outlines from embedded fonts.
+  // two-pass approach: first collect glyph IDs per font file (merging across
+  // all font objects sharing the same embedded file), then subset each file.
+  std::set<QPDFObjGen> processedFonts;
+  std::map<QPDFObjGen, std::set<uint16_t>> fontFileGlyphIds;
+  std::map<QPDFObjGen, QPDFObjectHandle> fontFileHandles;
+  std::map<QPDFObjGen, bool> fontFileCID; // true if CID font
+  std::set<QPDFObjGen> fontFileSkip;      // skip if any font fails safety check
+
+  // pass 1: collect glyph IDs from each font object
+  for (auto &[og, usedCodes] : fontUsedCodes) {
+    if (processedFonts.count(og))
+      continue;
+    processedFonts.insert(og);
+
+    auto fontObj = qpdf.getObjectByObjGen(og);
+    if (!fontObj.isDictionary())
+      continue;
+
+    auto subtype = fontObj.getKey("/Subtype");
+    if (!subtype.isName())
+      continue;
+    // Type0 composite fonts — subset CIDFontType2 and CIDFontType0
+    // descendants
+    if (subtype.getName() == "/Type0") {
+      // skip already-subset CID fonts
+      if (isAlreadySubset(fontObj))
+        continue;
+
+      auto descendants = fontObj.getKey("/DescendantFonts");
+      if (!descendants.isArray() || descendants.getArrayNItems() < 1)
+        continue;
+
+      auto cidFont = descendants.getArrayItem(0);
+      if (!cidFont.isDictionary())
+        continue;
+
+      if (isAlreadySubset(cidFont))
+        continue;
+
+      auto cidSubtype = cidFont.getKey("/Subtype");
+      if (!cidSubtype.isName())
+        continue;
+
+      bool isCIDFontType2 = cidSubtype.getName() == "/CIDFontType2";
+      bool isCIDFontType0 = cidSubtype.getName() == "/CIDFontType0";
+      if (!isCIDFontType2 && !isCIDFontType0)
+        continue;
+
+      auto cidDescriptor = cidFont.getKey("/FontDescriptor");
+      if (!cidDescriptor.isDictionary())
+        continue;
+
+      // determine which font file key to use:
+      // CIDFontType2 → /FontFile2 (TrueType)
+      // CIDFontType0 → /FontFile3 (CFF)
+      std::string fontFileKey;
+      if (isCIDFontType2 && cidDescriptor.hasKey("/FontFile2"))
+        fontFileKey = "/FontFile2";
+      else if (isCIDFontType0 && cidDescriptor.hasKey("/FontFile3"))
+        fontFileKey = "/FontFile3";
+      else
+        continue;
+
+      auto fontFile = cidDescriptor.getKey(fontFileKey);
+      if (!fontFile.isStream())
+        continue;
+
+      auto ffOg = fontFile.getObjGen();
+      fontFileHandles[ffOg] = fontFile;
+      fontFileCID[ffOg] = true;
+
+      try {
+        std::set<uint16_t> glyphIds;
+
+        auto cidToGid = cidFont.getKey("/CIDToGIDMap");
+        if (cidToGid.isName() && cidToGid.getName() == "/Identity") {
+          glyphIds = usedCodes;
+        } else if (cidToGid.isStream()) {
+          auto mapData = cidToGid.getStreamData(qpdf_dl_all);
+          const uint8_t *mapBuf = mapData->getBuffer();
+          size_t mapSize = mapData->getSize();
+          for (uint16_t cid : usedCodes) {
+            size_t offset = static_cast<size_t>(cid) * 2;
+            if (offset + 2 <= mapSize) {
+              uint16_t gid = static_cast<uint16_t>((mapBuf[offset] << 8) |
+                                                   mapBuf[offset + 1]);
+              if (gid != 0)
+                glyphIds.insert(gid);
+            }
+          }
+        } else if (isCIDFontType0) {
+          glyphIds = usedCodes;
+        } else {
+          continue;
+        }
+
+        glyphIds.insert(0);
+        fontFileGlyphIds[ffOg].insert(glyphIds.begin(), glyphIds.end());
+      } catch (...) {
+        continue;
+      }
+      continue;
+    }
+
+    // simple TrueType fonts
+    if (subtype.getName() != "/TrueType")
+      continue;
+
+    // skip already-subset fonts (BaseFont like "ABCDEF+FontName") — their
+    // custom encodings and glyph tables can't be reliably re-subset
+    // skip already-subset fonts — mark their font file as skip so other
+    // fonts sharing it won't subset and corrupt the already-subset glyph data
+    if (isAlreadySubset(fontObj)) {
+      auto descriptor = fontObj.getKey("/FontDescriptor");
+      if (descriptor.isDictionary() && descriptor.hasKey("/FontFile2")) {
+        auto fontFile = descriptor.getKey("/FontFile2");
+        if (fontFile.isStream())
+          fontFileSkip.insert(fontFile.getObjGen());
+      }
+      continue;
+    }
+
+    auto descriptor = fontObj.getKey("/FontDescriptor");
+    if (!descriptor.isDictionary() || !descriptor.hasKey("/FontFile2"))
+      continue;
+
+    auto fontFile = descriptor.getKey("/FontFile2");
+    if (!fontFile.isStream())
+      continue;
+
+    auto ffOg = fontFile.getObjGen();
+    fontFileHandles[ffOg] = fontFile;
+    if (!fontFileCID.count(ffOg))
+      fontFileCID[ffOg] = false;
+
+    try {
+      auto fontData = fontFile.getStreamData(qpdf_dl_all);
+      const uint8_t *ttfData = fontData->getBuffer();
+      size_t ttfSize = fontData->getSize();
+
+      std::set<uint16_t> glyphIds;
+
+      // build /Differences map to identify remapped codes
+      auto diffMap = getDifferencesCodeMap(fontObj);
+      std::set<uint16_t> diffCodes; // codes that have /Differences entries
+      for (auto &[code, name] : diffMap) {
+        if (usedCodes.count(code))
+          diffCodes.insert(code);
+      }
+      std::set<uint16_t> baseCodes; // codes using base encoding (no remap)
+      for (uint16_t code : usedCodes) {
+        if (!diffCodes.count(code))
+          baseCodes.insert(code);
+      }
+
+      bool hasToUnicode = false;
+
+      // strategy 1: /ToUnicode CMap — most reliable Unicode mapping
+      auto toUnicode = fontObj.getKey("/ToUnicode");
+      if (toUnicode.isStream()) {
+        hasToUnicode = true;
+        auto tuCodes = parseToUnicode(toUnicode, usedCodes);
+        if (!tuCodes.empty()) {
+          auto ids = mapCodesToGlyphIds(ttfData, ttfSize, tuCodes);
+          glyphIds.insert(ids.begin(), ids.end());
+        }
+      }
+
+      // strategy 2: /Encoding /Differences — glyph name lookup via post table
+      auto diffNames = getGlyphNamesFromEncoding(usedCodes, fontObj);
+      if (!diffNames.empty()) {
+        auto nameIds = mapGlyphNamesToGlyphIds(ttfData, ttfSize, diffNames);
+        glyphIds.insert(nameIds.begin(), nameIds.end());
+      }
+
+      // strategy 3: /Differences glyph names → Unicode → cmap lookup.
+      // converts glyph names to Unicode codepoints (via AGL/uniXXXX)
+      // and looks them up in the font's cmap. this catches characters like
+      // ẞ (uni1E9E), € (Euro), • (bullet) that have non-standard byte codes
+      // in /Differences but standard Unicode entries in the cmap.
+      if (!diffCodes.empty()) {
+        std::set<uint16_t> diffUnicodes;
+        for (uint16_t code : diffCodes) {
+          auto it = diffMap.find(code);
+          if (it != diffMap.end()) {
+            uint16_t unicode = glyphNameToUnicode(it->second);
+            if (unicode > 0)
+              diffUnicodes.insert(unicode);
+          }
+        }
+        if (!diffUnicodes.empty()) {
+          auto ids = mapCodesToGlyphIds(ttfData, ttfSize, diffUnicodes);
+          glyphIds.insert(ids.begin(), ids.end());
+        }
+      }
+
+      // strategy 4: base encoding conversion (WinAnsi, MacRoman) → cmap
+      // only for codes NOT remapped by /Differences — those are already
+      // handled by strategies 2 and 3 with correct Unicode
+      if (!baseCodes.empty()) {
+        auto unicodeCodes = convertCodesToUnicode(baseCodes, fontObj);
+        auto encIds = mapCodesToGlyphIds(ttfData, ttfSize, unicodeCodes);
+        glyphIds.insert(encIds.begin(), encIds.end());
+
+        // strategy 5: raw character codes as fallback — only when byte codes
+        // might directly index the cmap (no /ToUnicode remapping)
+        if (!hasToUnicode && unicodeCodes != baseCodes) {
+          auto rawGlyphs = mapCodesToGlyphIds(ttfData, ttfSize, baseCodes);
+          glyphIds.insert(rawGlyphs.begin(), rawGlyphs.end());
+        }
+
+        // strategy 6: "uniXXXX" glyph names via post table — catches fonts
+        // where glyphs have no cmap entry but are accessible by name
+        {
+          std::vector<std::string> uniNames;
+          for (uint16_t u : unicodeCodes) {
+            if (u > 0x7F) {
+              char buf[8];
+              snprintf(buf, sizeof(buf), "uni%04X", u);
+              uniNames.emplace_back(buf);
+            }
+          }
+          if (!uniNames.empty()) {
+            auto nameIds = mapGlyphNamesToGlyphIds(ttfData, ttfSize, uniNames);
+            glyphIds.insert(nameIds.begin(), nameIds.end());
+          }
+        }
+      }
+
+      // safety check: if we found fewer glyph IDs than used character codes,
+      // some characters couldn't be mapped — mark font file as unsafe to
+      // subset. if ANY font sharing this file fails, skip the entire file.
+      glyphIds.insert(0);
+      if (glyphIds.size() - 1 < usedCodes.size()) {
+        fontFileSkip.insert(ffOg);
+        continue;
+      }
+
+      fontFileGlyphIds[ffOg].insert(glyphIds.begin(), glyphIds.end());
+    } catch (...) {
+      continue;
+    }
+  }
+
+  // pass 2: subset each font file with merged glyph IDs from all font objects
+  for (auto &[ffOg, glyphIds] : fontFileGlyphIds) {
+    if (fontFileSkip.count(ffOg))
+      continue;
+
+    auto it = fontFileHandles.find(ffOg);
+    if (it == fontFileHandles.end())
+      continue;
+
+    auto &fontFile = it->second;
+    bool isCID = fontFileCID[ffOg];
+
+    try {
+      auto fontData = fontFile.getStreamData(qpdf_dl_all);
+      const uint8_t *rawData = fontData->getBuffer();
+      size_t rawSize = fontData->getSize();
+
+      std::vector<uint8_t> subsetResult;
+      if (!subsetFont(rawData, rawSize, glyphIds, subsetResult, !isCID))
+        continue;
+
+      if (subsetResult.size() >= rawSize)
+        continue;
+
+      std::string fontStr(reinterpret_cast<char *>(subsetResult.data()),
+                          subsetResult.size());
+      fontFile.replaceStreamData(fontStr, QPDFObjectHandle::newNull(),
+                                 QPDFObjectHandle::newNull());
+    } catch (...) {
+      continue;
+    }
+  }
+
+  // optimize CID font /W arrays — rebuild with only used CID entries
+  for (auto &[og, usedCodes] : fontUsedCodes) {
+    auto fontObj = qpdf.getObjectByObjGen(og);
+    if (!fontObj.isDictionary())
+      continue;
+
+    auto subtype = fontObj.getKey("/Subtype");
+    if (!subtype.isName() || subtype.getName() != "/Type0")
+      continue;
+
+    // skip already-subset Type0 fonts
+    if (isAlreadySubset(fontObj))
+      continue;
+
+    auto descendants = fontObj.getKey("/DescendantFonts");
+    if (!descendants.isArray() || descendants.getArrayNItems() < 1)
+      continue;
+
+    auto cidFont = descendants.getArrayItem(0);
+    if (!cidFont.isDictionary())
+      continue;
+
+    // skip already-subset CID fonts — their width tables may have
+    // custom CID mappings our usage collector doesn't fully capture
+    if (isAlreadySubset(cidFont))
+      continue;
+
+    auto w = cidFont.getKey("/W");
+    if (!w.isArray() || w.getArrayNItems() == 0)
+      continue;
+
+    // parse /W into CID → width value map
+    std::map<int, QPDFObjectHandle> cidWidths;
+    int n = w.getArrayNItems();
+    int i = 0;
+    while (i < n) {
+      auto first = w.getArrayItem(i);
+      if (!first.isInteger()) {
+        ++i;
+        continue;
+      }
+      int cidStart = static_cast<int>(first.getIntValue());
+      ++i;
+      if (i >= n)
+        break;
+
+      auto second = w.getArrayItem(i);
+      if (second.isArray()) {
+        // format: cidStart [w1 w2 w3 ...]
+        for (int j = 0; j < second.getArrayNItems(); ++j)
+          cidWidths[cidStart + j] = second.getArrayItem(j);
+        ++i;
+      } else if (second.isInteger()) {
+        // format: cidStart cidEnd sameWidth
+        int cidEnd = static_cast<int>(second.getIntValue());
+        ++i;
+        if (i >= n)
+          break;
+        auto width = w.getArrayItem(i);
+        for (int cid = cidStart; cid <= cidEnd; ++cid)
+          cidWidths[cid] = width;
+        ++i;
+      } else {
+        ++i;
+      }
+    }
+
+    // rebuild /W with only used CIDs grouped by consecutive runs
+    std::vector<int> sortedUsed;
+    for (uint16_t c : usedCodes) {
+      if (cidWidths.count(static_cast<int>(c)))
+        sortedUsed.push_back(static_cast<int>(c));
+    }
+    std::sort(sortedUsed.begin(), sortedUsed.end());
+
+    auto newW = QPDFObjectHandle::newArray();
+    size_t idx = 0;
+    while (idx < sortedUsed.size()) {
+      int start = sortedUsed[idx];
+      auto widths = QPDFObjectHandle::newArray();
+      widths.appendItem(cidWidths[start]);
+      ++idx;
+      while (idx < sortedUsed.size() &&
+             sortedUsed[idx] == sortedUsed[idx - 1] + 1) {
+        widths.appendItem(cidWidths[sortedUsed[idx]]);
+        ++idx;
+      }
+      newW.appendItem(QPDFObjectHandle::newInteger(start));
+      newW.appendItem(widths);
+    }
+
+    // only replace if the new /W has fewer entries
+    if (newW.getArrayNItems() < w.getArrayNItems())
+      cidFont.replaceKey("/W", newW);
+  }
+}