qpdf-compress 0.2.0 → 0.4.1

package/src/images.cc

@@ -2,6 +2,7 @@
 #include "jpeg.h"
 
 #include <algorithm>
+#include <cmath>
 #include <cstdint>
 #include <cstring>
 #include <limits>
@@ -72,6 +73,198 @@ static void cmykToRgb(const unsigned char *cmyk, unsigned char *rgb,
   }
 }
 
+// ---------------------------------------------------------------------------
+// Content stream CTM parser — find rendered image dimensions in points
+// ---------------------------------------------------------------------------
+
+// 3x3 affine matrix stored as [a b c d e f] (PDF standard order)
+struct Matrix {
+  double a = 1, b = 0, c = 0, d = 1, e = 0, f = 0;
+};
+
+static Matrix multiply(const Matrix &m1, const Matrix &m2) {
+  return {m1.a * m2.a + m1.b * m2.c,        m1.a * m2.b + m1.b * m2.d,
+          m1.c * m2.a + m1.d * m2.c,        m1.c * m2.b + m1.d * m2.d,
+          m1.e * m2.a + m1.f * m2.c + m2.e, m1.e * m2.b + m1.f * m2.d + m2.f};
+}
+
+// returns the rendered width and height in points for each image XObject name.
+// falls back to pageW/pageH if parsing fails or the image isn't found.
+static std::map<std::string, std::pair<double, double>>
+getImageRenderedSizes(QPDFPageObjectHelper &page) {
+  std::map<std::string, std::pair<double, double>> result;
+
+  auto pageObj = page.getObjectHandle();
+  auto contents = pageObj.getKey("/Contents");
+
+  std::string contentStr;
+  try {
+    if (contents.isStream()) {
+      auto buf = contents.getStreamData(qpdf_dl_generalized);
+      contentStr.assign(reinterpret_cast<const char *>(buf->getBuffer()),
+                        buf->getSize());
+    } else if (contents.isArray()) {
+      for (int i = 0; i < contents.getArrayNItems(); ++i) {
+        auto stream = contents.getArrayItem(i);
+        if (stream.isStream()) {
+          auto buf = stream.getStreamData(qpdf_dl_generalized);
+          contentStr.append(reinterpret_cast<const char *>(buf->getBuffer()),
+                            buf->getSize());
+          contentStr += '\n';
+        }
+      }
+    }
+  } catch (...) {
+    return result;
+  }
+
+  // simple tokenizer: split on whitespace, handle names (/Xxx)
+  std::vector<std::string> tokens;
+  size_t pos = 0;
+  while (pos < contentStr.size()) {
+    // skip whitespace
+    while (pos < contentStr.size() &&
+           (contentStr[pos] == ' ' || contentStr[pos] == '\n' ||
+            contentStr[pos] == '\r' || contentStr[pos] == '\t'))
+      ++pos;
+    if (pos >= contentStr.size())
+      break;
+
+    // skip comments
+    if (contentStr[pos] == '%') {
+      while (pos < contentStr.size() && contentStr[pos] != '\n')
+        ++pos;
+      continue;
+    }
+
+    // skip strings (we don't need them)
+    if (contentStr[pos] == '(') {
+      int depth = 1;
+      ++pos;
+      while (pos < contentStr.size() && depth > 0) {
+        if (contentStr[pos] == '\\') {
+          ++pos;
+          if (pos < contentStr.size())
+            ++pos;
+        } else {
+          if (contentStr[pos] == '(')
+            ++depth;
+          else if (contentStr[pos] == ')')
+            --depth;
+          ++pos;
+        }
+      }
+      continue;
+    }
+    if (contentStr[pos] == '<' && pos + 1 < contentStr.size() &&
+        contentStr[pos + 1] != '<') {
+      ++pos;
+      while (pos < contentStr.size() && contentStr[pos] != '>')
+        ++pos;
+      if (pos < contentStr.size())
+        ++pos;
+      continue;
+    }
+
+    // skip inline images (BI ... EI)
+    // handled after tokenization
+
+    // read token
+    size_t start = pos;
+    if (contentStr[pos] == '/') {
+      ++pos;
+      while (pos < contentStr.size() && contentStr[pos] != ' ' &&
+             contentStr[pos] != '\n' && contentStr[pos] != '\r' &&
+             contentStr[pos] != '\t' && contentStr[pos] != '/' &&
+             contentStr[pos] != '[' && contentStr[pos] != ']' &&
+             contentStr[pos] != '<' && contentStr[pos] != '>' &&
+             contentStr[pos] != '(' && contentStr[pos] != ')')
+        ++pos;
+    } else if (contentStr[pos] == '[' || contentStr[pos] == ']') {
+      ++pos;
+    } else if (contentStr[pos] == '<' && pos + 1 < contentStr.size() &&
+               contentStr[pos + 1] == '<') {
+      pos += 2; // <<
+    } else if (contentStr[pos] == '>' && pos + 1 < contentStr.size() &&
+               contentStr[pos + 1] == '>') {
+      pos += 2; // >>
+    } else {
+      while (pos < contentStr.size() && contentStr[pos] != ' ' &&
+             contentStr[pos] != '\n' && contentStr[pos] != '\r' &&
+             contentStr[pos] != '\t' && contentStr[pos] != '/' &&
+             contentStr[pos] != '[' && contentStr[pos] != ']' &&
+             contentStr[pos] != '<' && contentStr[pos] != '>' &&
+             contentStr[pos] != '(' && contentStr[pos] != ')')
+        ++pos;
+    }
+
+    if (pos > start)
+      tokens.emplace_back(contentStr.substr(start, pos - start));
+  }
+
+  // walk tokens tracking CTM
+  Matrix ctm;
+  std::vector<Matrix> stack;
+  std::vector<std::string> operandStack;
+
+  for (size_t i = 0; i < tokens.size(); ++i) {
+    auto &tok = tokens[i];
+
+    if (tok == "q") {
+      stack.push_back(ctm);
+      operandStack.clear();
+    } else if (tok == "Q") {
+      if (!stack.empty()) {
+        ctm = stack.back();
+        stack.pop_back();
+      }
+      operandStack.clear();
+    } else if (tok == "cm" && operandStack.size() >= 6) {
+      // cm operator: a b c d e f cm
+      try {
+        Matrix m;
+        m.a = std::stod(operandStack[operandStack.size() - 6]);
+        m.b = std::stod(operandStack[operandStack.size() - 5]);
+        m.c = std::stod(operandStack[operandStack.size() - 4]);
+        m.d = std::stod(operandStack[operandStack.size() - 3]);
+        m.e = std::stod(operandStack[operandStack.size() - 2]);
+        m.f = std::stod(operandStack[operandStack.size() - 1]);
+        ctm = multiply(m, ctm);
+      } catch (...) {
+      }
+      operandStack.clear();
+    } else if (tok == "Do" && !operandStack.empty()) {
+      // Do operator draws an XObject
+      auto &name = operandStack.back();
+      if (!name.empty() && name[0] == '/') {
+        // rendered width = sqrt(a^2 + c^2), height = sqrt(b^2 + d^2)
+        // (these are the lengths of the column vectors of the CTM)
+        double rw = std::sqrt(ctm.a * ctm.a + ctm.c * ctm.c);
+        double rh = std::sqrt(ctm.b * ctm.b + ctm.d * ctm.d);
+        // keep the largest rendered size if an image is drawn multiple times
+        auto it = result.find(name);
+        if (it == result.end() ||
+            rw * rh > it->second.first * it->second.second)
+          result[name] = {rw, rh};
+      }
+      operandStack.clear();
+    } else {
+      // it's an operand — check if it's an operator we don't track
+      // (PDF operators are always non-numeric alpha)
+      bool isOperator = !tok.empty() && tok[0] != '/' && tok[0] != '-' &&
+                        tok[0] != '+' && tok[0] != '.' &&
+                        !(tok[0] >= '0' && tok[0] <= '9');
+      if (isOperator) {
+        operandStack.clear();
+      } else {
+        operandStack.push_back(tok);
+      }
+    }
+  }
+
+  return result;
+}
+
 // ---------------------------------------------------------------------------
 // Bilinear downscaling
 // ---------------------------------------------------------------------------
@@ -118,15 +311,11 @@ static std::vector<uint8_t> bilinearDownscale(const unsigned char *src,
 // Image recompression for lossy mode
 // ---------------------------------------------------------------------------
 
-// auto-mode thresholds — only re-encode existing JPEGs whose estimated
-// quality exceeds kAutoSkipThreshold (avoids pointless re-encoding where
-// generation loss outweighs size savings).  Non-JPEG images and high-quality
-// JPEGs are (re-)encoded at kAutoTargetQuality.
-static constexpr int kAutoSkipThreshold = 90;
-static constexpr int kAutoTargetQuality = 85;
+// Image recompression thresholds are passed via CompressOptions:
+//   - lossless mode: skipThreshold=90, targetQuality=85  (conservative)
+//   - lossy mode:    skipThreshold=65, targetQuality=75  (aggressive)
 
 void optimizeImages(QPDF &qpdf, const CompressOptions &opts) {
-  const bool autoQuality = (opts.quality == 0);
   forEachImage(qpdf, [&](const std::string &, QPDFObjectHandle xobj,
                          QPDFObjectHandle, QPDFPageObjectHelper &) {
     auto dict = xobj.getDict();
@@ -192,39 +381,26 @@ void optimizeImages(QPDF &qpdf, const CompressOptions &opts) {
     bool isCurrentlyJpeg =
         currentFilter.isName() && currentFilter.getName() == "/DCTDecode";
 
-    // determine per-image target quality
-    int targetQuality = autoQuality ? kAutoTargetQuality : opts.quality;
-
-    // in auto mode, skip existing JPEGs unless their quality is very high
-    // (> 90) — re-encoding a q86 JPEG at q85 saves almost nothing but adds
-    // artifacts.  Only high-quality originals (92, 95, 100…) benefit from
-    // re-encoding down to 85.
+    // skip existing JPEGs that are already at or below the threshold —
+    // re-encoding them adds generation loss for negligible savings
     if (isCurrentlyJpeg && !isCMYK) {
       auto rawData = xobj.getRawStreamData();
       int existingQ =
           estimateJpegQuality(rawData->getBuffer(), rawData->getSize());
-      if (autoQuality) {
-        if (existingQ > 0 && existingQ <= kAutoSkipThreshold)
-          return;
-      } else {
-        // explicit quality: use existing ceiling logic
-        if (existingQ > 0 && existingQ <= targetQuality)
-          return;
-      }
+      if (existingQ > 0 && existingQ <= opts.skipThreshold)
+        return;
     }
 
     // encode as JPEG via libjpeg-turbo
     std::vector<uint8_t> jpegData;
-    if (!encodeJpeg(pixels, width, height, encodeComponents, targetQuality,
+    if (!encodeJpeg(pixels, width, height, encodeComponents, opts.targetQuality,
                     jpegData))
       return;
 
-    // only replace if we actually reduced size (for non-CMYK images)
-    if (isCurrentlyJpeg && !isCMYK) {
-      auto rawData = xobj.getRawStreamData();
-      if (jpegData.size() >= rawData->getSize())
-        return;
-    }
+    // only replace if we actually reduced size
+    auto rawData = xobj.getRawStreamData();
+    if (jpegData.size() >= rawData->getSize())
+      return;
 
     // replace stream data with JPEG
     std::string jpegStr(reinterpret_cast<char *>(jpegData.data()),
@@ -373,13 +549,16 @@ void optimizeExistingJpegs(QPDF &qpdf) {
 // DPI-based image downscaling
 // ---------------------------------------------------------------------------
 
-void downscaleImages(QPDF &qpdf, int maxDpi) {
+void downscaleImages(QPDF &qpdf, int maxDpi, int quality) {
   if (maxDpi <= 0)
     return;
 
   std::set<QPDFObjGen> processed;
+  // cache rendered sizes per page object (keyed by page objgen)
+  std::map<QPDFObjGen, std::map<std::string, std::pair<double, double>>>
+      pageSizesCache;
 
-  forEachImage(qpdf, [&](const std::string & /*key*/, QPDFObjectHandle xobj,
+  forEachImage(qpdf, [&](const std::string &key, QPDFObjectHandle xobj,
                          QPDFObjectHandle /*xobjects*/,
                          QPDFPageObjectHelper &page) {
     auto og = xobj.getObjGen();
@@ -407,27 +586,42 @@ void downscaleImages(QPDF &qpdf, int maxDpi) {
     if (components == 0)
       return;
 
-    // get page dimensions from MediaBox (in points, 72 per inch)
-    auto mediaBox = page.getAttribute("/MediaBox", false);
-    if (!mediaBox.isArray() || mediaBox.getArrayNItems() < 4)
-      return;
+    // get rendered size from CTM parsing, with MediaBox fallback
+    auto pageOg = page.getObjectHandle().getObjGen();
+    auto cacheIt = pageSizesCache.find(pageOg);
+    if (cacheIt == pageSizesCache.end()) {
+      pageSizesCache[pageOg] = getImageRenderedSizes(page);
+      cacheIt = pageSizesCache.find(pageOg);
+    }
 
-    double pageW = 0, pageH = 0;
-    try {
-      pageW = mediaBox.getArrayItem(2).getNumericValue() -
-              mediaBox.getArrayItem(0).getNumericValue();
-      pageH = mediaBox.getArrayItem(3).getNumericValue() -
-              mediaBox.getArrayItem(1).getNumericValue();
-    } catch (...) {
-      return;
+    double renderedW = 0, renderedH = 0;
+    auto sizeIt = cacheIt->second.find(key);
+    if (sizeIt != cacheIt->second.end() && sizeIt->second.first > 0 &&
+        sizeIt->second.second > 0) {
+      // CTM gives rendered size in points
+      renderedW = sizeIt->second.first;
+      renderedH = sizeIt->second.second;
+    } else {
+      // fallback: assume image fills page
+      auto mediaBox = page.getAttribute("/MediaBox", false);
+      if (!mediaBox.isArray() || mediaBox.getArrayNItems() < 4)
+        return;
+      try {
+        renderedW = mediaBox.getArrayItem(2).getNumericValue() -
+                    mediaBox.getArrayItem(0).getNumericValue();
+        renderedH = mediaBox.getArrayItem(3).getNumericValue() -
+                    mediaBox.getArrayItem(1).getNumericValue();
+      } catch (...) {
+        return;
+      }
     }
 
-    if (pageW <= 0 || pageH <= 0)
+    if (renderedW <= 0 || renderedH <= 0)
       return;
 
-    // estimate effective DPI (assumes image fills page — conservative)
-    double dpiX = imgW / (pageW / 72.0);
-    double dpiY = imgH / (pageH / 72.0);
+    // calculate effective DPI from rendered size in points (72 points/inch)
+    double dpiX = imgW / (renderedW / 72.0);
+    double dpiY = imgH / (renderedH / 72.0);
     double effectiveDpi = std::max(dpiX, dpiY);
 
     if (effectiveDpi <= maxDpi)
@@ -476,13 +670,20 @@ void downscaleImages(QPDF &qpdf, int maxDpi) {
     auto scaled =
         bilinearDownscale(pixels, imgW, imgH, downscaleComponents, newW, newH);
 
-    // re-encode as Flate-compressed raw pixels
-    auto newSize = static_cast<size_t>(newW) * newH * downscaleComponents;
-    if (scaled.size() != newSize)
+    // re-encode downscaled pixels as JPEG
+    std::vector<uint8_t> jpegData;
+    if (!encodeJpeg(scaled.data(), newW, newH, downscaleComponents, quality,
+                    jpegData))
       return;
 
-    std::string rawStr(reinterpret_cast<char *>(scaled.data()), scaled.size());
-    xobj.replaceStreamData(rawStr, QPDFObjectHandle::newName("/FlateDecode"),
+    // only replace if the JPEG is actually smaller than the original stream
+    auto rawData = xobj.getRawStreamData();
+    if (jpegData.size() >= rawData->getSize())
+      return;
+
+    std::string jpegStr(reinterpret_cast<char *>(jpegData.data()),
+                        jpegData.size());
+    xobj.replaceStreamData(jpegStr, QPDFObjectHandle::newName("/DCTDecode"),
                            QPDFObjectHandle::newNull());
 
     dict.replaceKey("/Width", QPDFObjectHandle::newInteger(newW));
@@ -501,96 +702,242 @@ void downscaleImages(QPDF &qpdf, int maxDpi) {
 }
 
 // ---------------------------------------------------------------------------
-// Metadata stripping
+// Grayscale detection — convert RGB images that are actually grayscale to
+// DeviceGray (1/3 the raw data size)
 // ---------------------------------------------------------------------------
 
-void stripMetadata(QPDF &qpdf) {
-  auto root = qpdf.getRoot();
-
-  // remove XMP metadata stream
-  if (root.hasKey("/Metadata"))
-    root.removeKey("/Metadata");
-
-  // remove document info dictionary
-  auto trailer = qpdf.getTrailer();
-  if (trailer.hasKey("/Info"))
-    trailer.removeKey("/Info");
-
-  // remove page-level metadata and PieceInfo
-  for (auto &page : QPDFPageDocumentHelper(qpdf).getAllPages()) {
-    auto pageObj = page.getObjectHandle();
-    if (pageObj.hasKey("/Metadata"))
-      pageObj.removeKey("/Metadata");
-    if (pageObj.hasKey("/PieceInfo"))
-      pageObj.removeKey("/PieceInfo");
-  }
+void convertGrayscaleImages(QPDF &qpdf) {
+  std::set<QPDFObjGen> processed;
 
-  // remove embedded thumbnails
-  for (auto &page : QPDFPageDocumentHelper(qpdf).getAllPages()) {
-    auto pageObj = page.getObjectHandle();
-    if (pageObj.hasKey("/Thumb"))
-      pageObj.removeKey("/Thumb");
-  }
+  forEachImage(qpdf, [&](const std::string & /*key*/, QPDFObjectHandle xobj,
+                         QPDFObjectHandle /*xobjects*/,
+                         QPDFPageObjectHelper & /*page*/) {
+    auto og = xobj.getObjGen();
+    if (processed.count(og))
+      return;
+    processed.insert(og);
 
-  // remove MarkInfo and page labels (optional metadata)
-  if (root.hasKey("/MarkInfo"))
-    root.removeKey("/MarkInfo");
+    auto dict = xobj.getDict();
+
+    // only handle 8-bit RGB images
+    if (!dict.getKey("/BitsPerComponent").isInteger() ||
+        dict.getKey("/BitsPerComponent").getIntValue() != 8)
+      return;
+
+    auto cs = dict.getKey("/ColorSpace");
+    if (!cs.isName() || cs.getName() != "/DeviceRGB")
+      return;
+
+    // skip JPEG-compressed images — converting to raw gray + Flate would be
+    // larger than the original JPEG. in lossy mode, optimizeImages downstream
+    // re-encodes, but in lossless mode nothing would, causing size inflation.
+    auto filter = dict.getKey("/Filter");
+    if (filter.isName() && filter.getName() == "/DCTDecode")
+      return;
+
+    int width = 0, height = 0;
+    if (dict.getKey("/Width").isInteger())
+      width = static_cast<int>(dict.getKey("/Width").getIntValue());
+    if (dict.getKey("/Height").isInteger())
+      height = static_cast<int>(dict.getKey("/Height").getIntValue());
+    if (width <= 0 || height <= 0)
+      return;
+
+    // decode pixels
+    std::shared_ptr<Buffer> streamData;
+    try {
+      streamData = xobj.getStreamData(qpdf_dl_all);
+    } catch (...) {
+      return;
+    }
+
+    auto w = static_cast<size_t>(width);
+    auto h = static_cast<size_t>(height);
+    size_t expectedSize = w * h * 3;
+    if (streamData->getSize() != expectedSize)
+      return;
+
+    const auto *pixels = streamData->getBuffer();
+    size_t pixelCount = w * h;
+
+    // check if all RGB triples have equal channels (R == G == B)
+    bool isGray = true;
+    for (size_t i = 0; i < pixelCount; ++i) {
+      auto r = pixels[i * 3 + 0];
+      auto g = pixels[i * 3 + 1];
+      auto b = pixels[i * 3 + 2];
+      if (r != g || g != b) {
+        isGray = false;
+        break;
+      }
+    }
+
+    if (!isGray)
+      return;
+
+    // build grayscale pixel buffer
+    std::vector<uint8_t> grayPixels(pixelCount);
+    for (size_t i = 0; i < pixelCount; ++i)
+      grayPixels[i] = pixels[i * 3];
+
+    // replace stream with raw grayscale data (Flate-compressed by QPDFWriter)
+    std::string grayStr(reinterpret_cast<char *>(grayPixels.data()),
+                        grayPixels.size());
+    xobj.replaceStreamData(grayStr, QPDFObjectHandle::newNull(),
+                           QPDFObjectHandle::newNull());
+    dict.replaceKey("/ColorSpace", QPDFObjectHandle::newName("/DeviceGray"));
+
+    // remove JPEG-specific params
+    if (dict.hasKey("/DecodeParms"))
+      dict.removeKey("/DecodeParms");
+    if (dict.hasKey("/Predictor"))
+      dict.removeKey("/Predictor");
+  });
 }
 
 // ---------------------------------------------------------------------------
-// Remove unused font resources
+// Bitonal conversion — convert 8-bit grayscale images that are effectively
+// black & white (all pixels near 0 or 255) to 1-bit, saving ~8x raw data
 // ---------------------------------------------------------------------------
 
-void removeUnusedFonts(QPDF &qpdf) {
-  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;
+void convertBitonalImages(QPDF &qpdf) {
+  std::set<QPDFObjGen> processed;
 
-    // collect all font names referenced in this page's content stream(s)
-    std::set<std::string> usedFonts;
+  forEachImage(qpdf, [&](const std::string & /*key*/, QPDFObjectHandle xobj,
+                         QPDFObjectHandle /*xobjects*/,
+                         QPDFPageObjectHelper & /*page*/) {
+    auto og = xobj.getObjGen();
+    if (processed.count(og))
+      return;
+    processed.insert(og);
+
+    auto dict = xobj.getDict();
 
+    // only handle 8-bit grayscale images
+    if (!dict.getKey("/BitsPerComponent").isInteger() ||
+        dict.getKey("/BitsPerComponent").getIntValue() != 8)
+      return;
+
+    auto cs = dict.getKey("/ColorSpace");
+    if (!cs.isName() || cs.getName() != "/DeviceGray")
+      return;
+
+    // skip images with masks (bitonal conversion may not be safe)
+    if (dict.hasKey("/SMask") || dict.hasKey("/Mask"))
+      return;
+
+    int width = 0, height = 0;
+    if (dict.getKey("/Width").isInteger())
+      width = static_cast<int>(dict.getKey("/Width").getIntValue());
+    if (dict.getKey("/Height").isInteger())
+      height = static_cast<int>(dict.getKey("/Height").getIntValue());
+    if (width <= 0 || height <= 0)
+      return;
+
+    // decode pixels
+    std::shared_ptr<Buffer> streamData;
     try {
-      // get unparsed content stream data
-      auto contents = pageObj.getKey("/Contents");
-      std::string contentStr;
-
-      if (contents.isStream()) {
-        auto buf = contents.getStreamData(qpdf_dl_generalized);
-        contentStr.assign(reinterpret_cast<const char *>(buf->getBuffer()),
-                          buf->getSize());
-      } else if (contents.isArray()) {
-        for (int i = 0; i < contents.getArrayNItems(); ++i) {
-          auto stream = contents.getArrayItem(i);
-          if (stream.isStream()) {
-            auto buf = stream.getStreamData(qpdf_dl_generalized);
-            contentStr.append(reinterpret_cast<const char *>(buf->getBuffer()),
-                              buf->getSize());
-            contentStr += '\n';
-          }
-        }
+      streamData = xobj.getStreamData(qpdf_dl_all);
+    } catch (...) {
+      return;
+    }
+
+    auto w = static_cast<size_t>(width);
+    auto h = static_cast<size_t>(height);
+    if (streamData->getSize() != w * h)
+      return;
+
+    const auto *pixels = streamData->getBuffer();
+    size_t pixelCount = w * h;
+
+    // check if all pixels are near black (<=32) or near white (>=224)
+    bool isBitonal = true;
+    for (size_t i = 0; i < pixelCount; ++i) {
+      if (pixels[i] > 32 && pixels[i] < 224) {
+        isBitonal = false;
+        break;
       }
+    }
+
+    if (!isBitonal)
+      return;
 
-      // scan for /FontName references — Tf operator uses font name
-      // pattern: /FontName <size> Tf
-      for (auto &fontKey : fonts.getKeys()) {
-        // fontKey includes the leading '/', e.g. "/F1"
-        if (contentStr.find(fontKey) != std::string::npos)
-          usedFonts.insert(fontKey);
+    // pack into 1-bit: 0 = black, 1 = white
+    // each row padded to byte boundary
+    size_t rowBytes = (w + 7) / 8;
+    std::vector<uint8_t> bitonalData(rowBytes * h, 0);
+
+    for (size_t y = 0; y < h; ++y) {
+      for (size_t x = 0; x < w; ++x) {
+        bool white = pixels[y * w + x] >= 224;
+        if (white)
+          bitonalData[y * rowBytes + x / 8] |=
+              static_cast<uint8_t>(0x80 >> (x % 8));
       }
-    } catch (...) {
-      continue; // skip this page if content can't be read
     }
 
-    // remove fonts that are not referenced in the content stream
-    auto allFontKeys = fonts.getKeys();
-    for (auto &fontKey : allFontKeys) {
-      if (usedFonts.find(fontKey) == usedFonts.end())
-        fonts.removeKey(fontKey);
+    // only replace if 1-bit data is smaller than original raw stream
+    auto rawData = xobj.getRawStreamData();
+    if (bitonalData.size() >= rawData->getSize())
+      return;
+
+    std::string bitStr(reinterpret_cast<char *>(bitonalData.data()),
+                       bitonalData.size());
+    xobj.replaceStreamData(bitStr, QPDFObjectHandle::newNull(),
+                           QPDFObjectHandle::newNull());
+    dict.replaceKey("/BitsPerComponent", QPDFObjectHandle::newInteger(1));
+
+    if (dict.hasKey("/DecodeParms"))
+      dict.removeKey("/DecodeParms");
+    if (dict.hasKey("/Predictor"))
+      dict.removeKey("/Predictor");
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Soft mask optimization — losslessly optimize /SMask JPEG streams
+// ---------------------------------------------------------------------------
+
+void optimizeSoftMasks(QPDF &qpdf) {
+  std::set<QPDFObjGen> processed;
+
+  forEachImage(qpdf, [&](const std::string & /*key*/, QPDFObjectHandle xobj,
+                         QPDFObjectHandle /*xobjects*/,
+                         QPDFPageObjectHelper & /*page*/) {
+    auto dict = xobj.getDict();
+    if (!dict.hasKey("/SMask"))
+      return;
+
+    auto smask = dict.getKey("/SMask");
+    if (!smask.isStream())
+      return;
+
+    auto og = smask.getObjGen();
+    if (processed.count(og))
+      return;
+    processed.insert(og);
+
+    auto smaskDict = smask.getDict();
+    auto filter = smaskDict.getKey("/Filter");
+    if (!filter.isName() || filter.getName() != "/DCTDecode")
+      return;
+
+    try {
+      auto rawData = smask.getRawStreamData();
+
+      std::vector<uint8_t> optimized;
+      if (!losslessJpegOptimize(rawData->getBuffer(), rawData->getSize(),
+                                optimized))
+        return;
+
+      if (optimized.size() >= rawData->getSize())
+        return;
+
+      std::string jpegStr(reinterpret_cast<char *>(optimized.data()),
+                          optimized.size());
+      smask.replaceStreamData(jpegStr, QPDFObjectHandle::newName("/DCTDecode"),
+                              QPDFObjectHandle::newNull());
+    } catch (...) {
     }
-  }
+  });
 }