qpdf-compress 0.6.1 → 0.6.2

package/src/fonts.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include <qpdf/QPDF.hh>
+
+void optimizeFonts(QPDF &qpdf);

package/src/hash_utils.h

@@ -0,0 +1,15 @@
+// FNV-1a hash utility — shared between image deduplication and stream
+// deduplication
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+inline uint64_t fnv1aHash(const uint8_t *data, size_t size) {
+  uint64_t hash = 14695981039346656037ULL;
+  for (size_t i = 0; i < size; ++i) {
+    hash ^= static_cast<uint64_t>(data[i]);
+    hash *= 1099511628211ULL;
+  }
+  return hash;
+}

package/src/images.cc

@@ -1,10 +1,20 @@
 #include "images.h"
+#include "hash_utils.h"
 #include "jpeg.h"
 
 #include <algorithm>
 #include <cmath>
 #include <cstdint>
+#include <cstdlib>
 #include <cstring>
+
+#ifdef __APPLE__
+#include <xlocale.h>
+#elif defined(_WIN32)
+#include <locale.h>
+#else
+#include <locale.h>
+#endif
 #include <limits>
 #include <map>
 #include <set>
@@ -12,6 +22,17 @@
 
 #include <qpdf/Buffer.hh>
 
+// locale-independent double parser for PDF content stream operands
+static double parsePdfDouble(const std::string &s) {
+#ifdef _WIN32
+  static _locale_t c_locale = _create_locale(LC_NUMERIC, "C");
+  return _strtod_l(s.c_str(), nullptr, c_locale);
+#else
+  static locale_t c_locale = newlocale(LC_NUMERIC_MASK, "C", (locale_t)0);
+  return strtod_l(s.c_str(), nullptr, c_locale);
+#endif
+}
+
 // ---------------------------------------------------------------------------
 // Color space helpers
 // ---------------------------------------------------------------------------
@@ -223,12 +244,12 @@ getImageRenderedSizes(QPDFPageObjectHelper &page) {
       // 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]);
+        m.a = parsePdfDouble(operandStack[operandStack.size() - 6]);
+        m.b = parsePdfDouble(operandStack[operandStack.size() - 5]);
+        m.c = parsePdfDouble(operandStack[operandStack.size() - 4]);
+        m.d = parsePdfDouble(operandStack[operandStack.size() - 3]);
+        m.e = parsePdfDouble(operandStack[operandStack.size() - 2]);
+        m.f = parsePdfDouble(operandStack[operandStack.size() - 1]);
         ctm = multiply(m, ctm);
       } catch (...) {
       }
@@ -403,10 +424,7 @@ void optimizeImages(QPDF &qpdf, const CompressOptions &opts) {
       return;
 
     // replace stream data with JPEG
-    std::string jpegStr(reinterpret_cast<char *>(jpegData.data()),
-                        jpegData.size());
-    xobj.replaceStreamData(jpegStr, QPDFObjectHandle::newName("/DCTDecode"),
-                           QPDFObjectHandle::newNull());
+    replaceWithJpeg(xobj, jpegData);
 
     // update color space to DeviceRGB if converted from CMYK/ICCBased
     if (isCMYK || !dict.getKey("/ColorSpace").isName() ||
@@ -453,13 +471,7 @@ void deduplicateImages(QPDF &qpdf) {
       auto rawData = xobj.getRawStreamData();
       size_t size = rawData->getSize();
 
-      // FNV-1a hash
-      uint64_t hash = 14695981039346656037ULL;
-      auto *p = rawData->getBuffer();
-      for (size_t i = 0; i < size; ++i) {
-        hash ^= static_cast<uint64_t>(p[i]);
-        hash *= 1099511628211ULL;
-      }
+      uint64_t hash = fnv1aHash(rawData->getBuffer(), size);
 
       hashGroups[hash].push_back({og, size, xobj});
     } catch (...) {
@@ -536,10 +548,7 @@ void optimizeExistingJpegs(QPDF &qpdf) {
       if (optimized.size() >= rawData->getSize())
         return;
 
-      std::string jpegStr(reinterpret_cast<char *>(optimized.data()),
-                          optimized.size());
-      xobj.replaceStreamData(jpegStr, QPDFObjectHandle::newName("/DCTDecode"),
-                             QPDFObjectHandle::newNull());
+      replaceWithJpeg(xobj, optimized);
     } catch (...) {
     }
   });
@@ -681,10 +690,7 @@ void downscaleImages(QPDF &qpdf, int maxDpi, int quality) {
     if (jpegData.size() >= rawData->getSize())
       return;
 
-    std::string jpegStr(reinterpret_cast<char *>(jpegData.data()),
-                        jpegData.size());
-    xobj.replaceStreamData(jpegStr, QPDFObjectHandle::newName("/DCTDecode"),
-                           QPDFObjectHandle::newNull());
+    replaceWithJpeg(xobj, jpegData);
 
     dict.replaceKey("/Width", QPDFObjectHandle::newInteger(newW));
     dict.replaceKey("/Height", QPDFObjectHandle::newInteger(newH));
@@ -702,11 +708,13 @@ void downscaleImages(QPDF &qpdf, int maxDpi, int quality) {
 }
 
 // ---------------------------------------------------------------------------
-// Grayscale detection — convert RGB images that are actually grayscale to
-// DeviceGray (1/3 the raw data size)
+// Color space optimization — single pass over all images:
+// 1. Replace ICCBased color spaces with Device equivalents
+// 2. Convert RGB images that are actually grayscale to DeviceGray
+// 3. Convert 8-bit grayscale images that are black & white to 1-bit
 // ---------------------------------------------------------------------------
 
-void convertGrayscaleImages(QPDF &qpdf) {
+void optimizeColorSpaces(QPDF &qpdf) {
   std::set<QPDFObjGen> processed;
 
   forEachImage(qpdf, [&](const std::string & /*key*/, QPDFObjectHandle xobj,
@@ -719,20 +727,37 @@ void convertGrayscaleImages(QPDF &qpdf) {
 
     auto dict = xobj.getDict();
 
-    // only handle 8-bit RGB images
-    if (!dict.getKey("/BitsPerComponent").isInteger() ||
-        dict.getKey("/BitsPerComponent").getIntValue() != 8)
-      return;
-
+    // --- phase 1: strip ICC profiles ---
     auto cs = dict.getKey("/ColorSpace");
-    if (!cs.isName() || cs.getName() != "/DeviceRGB")
+    if (cs.isArray() && cs.getArrayNItems() >= 2) {
+      auto csName = cs.getArrayItem(0);
+      if (csName.isName() && csName.getName() == "/ICCBased") {
+        auto profile = cs.getArrayItem(1);
+        if (profile.isStream()) {
+          auto n = profile.getDict().getKey("/N");
+          if (n.isInteger()) {
+            int components = static_cast<int>(n.getIntValue());
+            if (components == 3)
+              dict.replaceKey("/ColorSpace",
+                              QPDFObjectHandle::newName("/DeviceRGB"));
+            else if (components == 1)
+              dict.replaceKey("/ColorSpace",
+                              QPDFObjectHandle::newName("/DeviceGray"));
+            else if (components == 4)
+              dict.replaceKey("/ColorSpace",
+                              QPDFObjectHandle::newName("/DeviceCMYK"));
+          }
+        }
+      }
+    }
+
+    // re-read after potential ICC replacement
+    cs = dict.getKey("/ColorSpace");
+    if (!cs.isName())
       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")
+    if (!dict.getKey("/BitsPerComponent").isInteger() ||
+        dict.getKey("/BitsPerComponent").getIntValue() != 8)
       return;
 
     int width = 0, height = 0;
@@ -743,114 +768,86 @@ void convertGrayscaleImages(QPDF &qpdf) {
     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;
+    // --- phase 2: RGB → grayscale detection ---
+    if (cs.getName() == "/DeviceRGB") {
+      // skip JPEG-compressed images — converting to raw gray + Flate would be
+      // larger than the original JPEG
+      auto filter = dict.getKey("/Filter");
+      if (filter.isName() && filter.getName() == "/DCTDecode")
+        return;
+      if (filter.isArray()) {
+        for (int i = 0; i < filter.getArrayNItems(); ++i) {
+          auto f = filter.getArrayItem(i);
+          if (f.isName() && f.getName() == "/DCTDecode")
+            return;
+        }
       }
-    }
 
-    if (!isGray)
-      return;
+      std::shared_ptr<Buffer> streamData;
+      try {
+        streamData = xobj.getStreamData(qpdf_dl_all);
+      } catch (...) {
+        return;
+      }
 
-    // build grayscale pixel buffer
-    std::vector<uint8_t> grayPixels(pixelCount);
-    for (size_t i = 0; i < pixelCount; ++i)
-      grayPixels[i] = pixels[i * 3];
+      if (streamData->getSize() != w * h * 3)
+        return;
 
-    // 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"));
+      const auto *pixels = streamData->getBuffer();
+      size_t pixelCount = w * h;
 
-    // remove JPEG-specific params
-    if (dict.hasKey("/DecodeParms"))
-      dict.removeKey("/DecodeParms");
-    if (dict.hasKey("/Predictor"))
-      dict.removeKey("/Predictor");
-  });
-}
+      bool isGray = true;
+      for (size_t i = 0; i < pixelCount; ++i) {
+        if (pixels[i * 3] != pixels[i * 3 + 1] ||
+            pixels[i * 3 + 1] != pixels[i * 3 + 2]) {
+          isGray = false;
+          break;
+        }
+      }
 
-// ---------------------------------------------------------------------------
-// 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
-// ---------------------------------------------------------------------------
+      if (!isGray)
+        return;
 
-void convertBitonalImages(QPDF &qpdf) {
-  std::set<QPDFObjGen> processed;
+      std::vector<uint8_t> grayPixels(pixelCount);
+      for (size_t i = 0; i < pixelCount; ++i)
+        grayPixels[i] = pixels[i * 3];
 
-  forEachImage(qpdf, [&](const std::string & /*key*/, QPDFObjectHandle xobj,
-                         QPDFObjectHandle /*xobjects*/,
-                         QPDFPageObjectHelper & /*page*/) {
-    auto og = xobj.getObjGen();
-    if (processed.count(og))
-      return;
-    processed.insert(og);
+      replaceWithRaw(xobj, grayPixels);
+      dict.replaceKey("/ColorSpace", QPDFObjectHandle::newName("/DeviceGray"));
 
-    auto dict = xobj.getDict();
+      if (dict.hasKey("/DecodeParms"))
+        dict.removeKey("/DecodeParms");
+      if (dict.hasKey("/Predictor"))
+        dict.removeKey("/Predictor");
 
-    // only handle 8-bit grayscale images
-    if (!dict.getKey("/BitsPerComponent").isInteger() ||
-        dict.getKey("/BitsPerComponent").getIntValue() != 8)
-      return;
+      // fall through to bitonal check on the now-gray image
+      cs = dict.getKey("/ColorSpace");
+    }
 
-    auto cs = dict.getKey("/ColorSpace");
-    if (!cs.isName() || cs.getName() != "/DeviceGray")
+    // --- phase 3: grayscale → bitonal conversion ---
+    if (cs.getName() != "/DeviceGray")
       return;
 
-    // skip images with masks (bitonal conversion may not be safe)
+    // skip images with masks
     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;
+    std::shared_ptr<Buffer> grayData;
     try {
-      streamData = xobj.getStreamData(qpdf_dl_all);
+      grayData = 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)
+    if (grayData->getSize() != w * h)
       return;
 
-    const auto *pixels = streamData->getBuffer();
+    const auto *pixels = grayData->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) {
@@ -862,29 +859,22 @@ void convertBitonalImages(QPDF &qpdf) {
     if (!isBitonal)
       return;
 
-    // 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)
+        if (pixels[y * w + x] >= 224)
           bitonalData[y * rowBytes + x / 8] |=
               static_cast<uint8_t>(0x80 >> (x % 8));
       }
     }
 
-    // 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());
+    replaceWithRaw(xobj, bitonalData);
     dict.replaceKey("/BitsPerComponent", QPDFObjectHandle::newInteger(1));
 
     if (dict.hasKey("/DecodeParms"))
@@ -892,6 +882,43 @@ void convertBitonalImages(QPDF &qpdf) {
     if (dict.hasKey("/Predictor"))
       dict.removeKey("/Predictor");
   });
+
+  // strip ICC profiles from page-level color space resources
+  for (auto &page : QPDFPageDocumentHelper(qpdf).getAllPages()) {
+    auto resources = page.getObjectHandle().getKey("/Resources");
+    if (!resources.isDictionary())
+      continue;
+
+    auto colorSpaces = resources.getKey("/ColorSpace");
+    if (!colorSpaces.isDictionary())
+      continue;
+
+    for (auto &key : colorSpaces.getKeys()) {
+      auto cs = colorSpaces.getKey(key);
+      if (!cs.isArray() || cs.getArrayNItems() < 2)
+        continue;
+
+      auto csName = cs.getArrayItem(0);
+      if (!csName.isName() || csName.getName() != "/ICCBased")
+        continue;
+
+      auto profile = cs.getArrayItem(1);
+      if (!profile.isStream())
+        continue;
+
+      auto n = profile.getDict().getKey("/N");
+      if (!n.isInteger())
+        continue;
+
+      int components = static_cast<int>(n.getIntValue());
+      if (components == 3)
+        colorSpaces.replaceKey(key, QPDFObjectHandle::newName("/DeviceRGB"));
+      else if (components == 1)
+        colorSpaces.replaceKey(key, QPDFObjectHandle::newName("/DeviceGray"));
+      else if (components == 4)
+        colorSpaces.replaceKey(key, QPDFObjectHandle::newName("/DeviceCMYK"));
+    }
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -933,10 +960,7 @@ void optimizeSoftMasks(QPDF &qpdf) {
       if (optimized.size() >= rawData->getSize())
         return;
 
-      std::string jpegStr(reinterpret_cast<char *>(optimized.data()),
-                          optimized.size());
-      smask.replaceStreamData(jpegStr, QPDFObjectHandle::newName("/DCTDecode"),
-                              QPDFObjectHandle::newNull());
+      replaceWithJpeg(smask, optimized);
     } catch (...) {
     }
   });

package/src/images.h

@@ -1,5 +1,9 @@
 #pragma once
 
+#include <cstdint>
+#include <string>
+#include <vector>
+
 #include <qpdf/QPDF.hh>
 #include <qpdf/QPDFObjectHandle.hh>
 #include <qpdf/QPDFPageDocumentHelper.hh>
@@ -28,6 +32,21 @@ template <typename Fn> void forEachImage(QPDF &qpdf, Fn &&fn) {
   }
 }
 
+// replace an image XObject's stream data with JPEG-encoded bytes
+inline void replaceWithJpeg(QPDFObjectHandle xobj, std::vector<uint8_t> &data) {
+  std::string str(reinterpret_cast<char *>(data.data()), data.size());
+  xobj.replaceStreamData(str, QPDFObjectHandle::newName("/DCTDecode"),
+                         QPDFObjectHandle::newNull());
+}
+
+// replace an image XObject's stream data with raw bytes (Flate-compressed by
+// QPDFWriter)
+inline void replaceWithRaw(QPDFObjectHandle xobj, std::vector<uint8_t> &data) {
+  std::string str(reinterpret_cast<char *>(data.data()), data.size());
+  xobj.replaceStreamData(str, QPDFObjectHandle::newNull(),
+                         QPDFObjectHandle::newNull());
+}
+
 struct CompressOptions {
   int skipThreshold = 0; // skip existing JPEGs at or below this quality
   int targetQuality = 0; // encode/re-encode at this quality
@@ -37,6 +56,5 @@ void optimizeImages(QPDF &qpdf, const CompressOptions &opts);
 void downscaleImages(QPDF &qpdf, int maxDpi, int quality);
 void deduplicateImages(QPDF &qpdf);
 void optimizeExistingJpegs(QPDF &qpdf);
-void convertGrayscaleImages(QPDF &qpdf);
-void convertBitonalImages(QPDF &qpdf);
+void optimizeColorSpaces(QPDF &qpdf);
 void optimizeSoftMasks(QPDF &qpdf);

package/src/jpeg.cc

@@ -8,6 +8,9 @@ void jpegErrorExit(j_common_ptr cinfo) {
   std::longjmp(myerr->jmpbuf, 1);
 }
 
+// suppress non-fatal warnings (e.g. "Corrupt JPEG data: N extraneous bytes")
+void jpegSilenceOutput(j_common_ptr) {}
+
 // ---------------------------------------------------------------------------
 // Lossless JPEG optimization
 // ---------------------------------------------------------------------------
@@ -22,6 +25,7 @@ static bool losslessJpegOptimizeImpl(const unsigned char *data, size_t size,
 
   srcinfo.err = jpeg_std_error(&jerr.pub);
   jerr.pub.error_exit = jpegErrorExit;
+  jerr.pub.output_message = jpegSilenceOutput;
   dstinfo.err = &jerr.pub;
 
   if (setjmp(jerr.jmpbuf)) {
@@ -95,6 +99,7 @@ static bool encodeJpegImpl(const unsigned char *pixels, int width, int height,
 
   cinfo.err = jpeg_std_error(&jerr.pub);
   jerr.pub.error_exit = jpegErrorExit;
+  jerr.pub.output_message = jpegSilenceOutput;
 
   if (setjmp(jerr.jmpbuf)) {
     jpeg_destroy_compress(&cinfo);
@@ -176,6 +181,7 @@ static int estimateJpegQualityImpl(const unsigned char *data, size_t size) {
 
   cinfo.err = jpeg_std_error(&jerr.pub);
   jerr.pub.error_exit = jpegErrorExit;
+  jerr.pub.output_message = jpegSilenceOutput;
 
   if (setjmp(jerr.jmpbuf)) {
     jpeg_destroy_decompress(&cinfo);

package/src/jpeg.h

@@ -15,6 +15,7 @@ struct JpegErrorMgr {
 };
 
 void jpegErrorExit(j_common_ptr cinfo);
+void jpegSilenceOutput(j_common_ptr cinfo);
 
 // rewrites Huffman tables at DCT coefficient level (2–15% savings, zero quality
 // loss)

package/src/optimize.h

@@ -1,15 +1,7 @@
+// umbrella include for all optimization passes
 #pragma once
 
-#include <qpdf/QPDF.hh>
-
-void stripMetadata(QPDF &qpdf);
-void removeUnusedFonts(QPDF &qpdf);
-void coalesceContentStreams(QPDF &qpdf);
-void deduplicateStreams(QPDF &qpdf);
-void subsetFonts(QPDF &qpdf);
-void stripIccProfiles(QPDF &qpdf);
-void stripEmbeddedFiles(QPDF &qpdf);
-void stripJavaScript(QPDF &qpdf);
-void flattenForms(QPDF &qpdf);
-void flattenPageTree(QPDF &qpdf);
-void minifyContentStreams(QPDF &qpdf);
+#include "content.h"
+#include "fonts.h"
+#include "strip.h"
+#include "structure.h"