qpdf-compress 0.2.0 → 0.4.1

package/src/optimize.h

@@ -0,0 +1,15 @@
+#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);

package/src/qpdf_addon.cc

@@ -14,6 +14,7 @@
 #include <qpdf/QPDFWriter.hh>
 
 #include "images.h"
+#include "optimize.h"
 
 // ---------------------------------------------------------------------------
 // File output helper — returns empty string on success, error message on
@@ -51,20 +52,17 @@ class CompressWorker : public Napi::AsyncWorker {
 public:
   // buffer variant
   CompressWorker(Napi::Env env, std::vector<uint8_t> data, bool lossy,
-                 int quality, int maxDpi, bool stripMeta,
-                 std::string outputPath)
+                 bool stripMeta, std::string outputPath)
       : Napi::AsyncWorker(env), deferred_(Napi::Promise::Deferred::New(env)),
-        bufferData_(std::move(data)), lossy_(lossy), quality_(quality),
-        maxDpi_(maxDpi), stripMeta_(stripMeta), useFile_(false),
-        outputPath_(std::move(outputPath)) {}
+        bufferData_(std::move(data)), lossy_(lossy), stripMeta_(stripMeta),
+        useFile_(false), outputPath_(std::move(outputPath)) {}
 
   // file path variant
-  CompressWorker(Napi::Env env, std::string path, bool lossy, int quality,
-                 int maxDpi, bool stripMeta, std::string outputPath)
+  CompressWorker(Napi::Env env, std::string path, bool lossy, bool stripMeta,
+                 std::string outputPath)
       : Napi::AsyncWorker(env), deferred_(Napi::Promise::Deferred::New(env)),
-        filePath_(std::move(path)), lossy_(lossy), quality_(quality),
-        maxDpi_(maxDpi), stripMeta_(stripMeta), useFile_(true),
-        outputPath_(std::move(outputPath)) {}
+        filePath_(std::move(path)), lossy_(lossy), stripMeta_(stripMeta),
+        useFile_(true), outputPath_(std::move(outputPath)) {}
 
   Napi::Promise Promise() { return deferred_.Promise(); }
 
@@ -93,15 +91,31 @@ protected:
       }
 
       deduplicateImages(qpdf);
+      convertGrayscaleImages(qpdf);
+      convertBitonalImages(qpdf);
+      flattenPageTree(qpdf);
+
       if (lossy_) {
+        // lossy: re-encode high-quality JPEGs at lower quality
         CompressOptions opts;
-        opts.quality = quality_;
+        opts.skipThreshold = 65;
+        opts.targetQuality = 75;
         optimizeImages(qpdf, opts);
+        downscaleImages(qpdf, 72, 75);
       }
-      if (maxDpi_ > 0)
-        downscaleImages(qpdf, maxDpi_);
+
+      // lossless Huffman optimization for all existing JPEGs
       optimizeExistingJpegs(qpdf);
+      optimizeSoftMasks(qpdf);
       removeUnusedFonts(qpdf);
+      subsetFonts(qpdf);
+      stripIccProfiles(qpdf);
+      flattenForms(qpdf);
+      coalesceContentStreams(qpdf);
+      minifyContentStreams(qpdf);
+      deduplicateStreams(qpdf);
+      stripEmbeddedFiles(qpdf);
+      stripJavaScript(qpdf);
       if (stripMeta_)
         stripMetadata(qpdf);
 
@@ -109,6 +123,7 @@ protected:
 
       QPDFWriter writer(qpdf);
       writer.setOutputMemory();
+      writer.setLinearization(false);
       writer.setStreamDataMode(qpdf_s_compress);
       writer.setRecompressFlate(true);
       writer.setObjectStreamMode(qpdf_o_generate);
@@ -153,8 +168,6 @@ private:
   std::vector<uint8_t> bufferData_;
   std::string filePath_;
   bool lossy_;
-  int quality_;
-  int maxDpi_;
   bool stripMeta_;
   bool useFile_;
   std::string outputPath_;
@@ -175,37 +188,14 @@ static Napi::Value Compress(const Napi::CallbackInfo &info) {
   }
 
   bool lossy = false;
-  int quality = 0;
-  int maxDpi = 0;
   bool stripMeta = false;
   std::string outputPath;
 
   if (info.Length() >= 2 && info[1].IsObject()) {
     auto options = info[1].As<Napi::Object>();
 
-    if (options.Has("mode")) {
-      auto mode = options.Get("mode").As<Napi::String>().Utf8Value();
-      if (mode != "lossy" && mode != "lossless") {
-        Napi::TypeError::New(env, "Mode must be 'lossy' or 'lossless'")
-            .ThrowAsJavaScriptException();
-        return env.Undefined();
-      }
-      lossy = (mode == "lossy");
-    }
-
-    if (options.Has("quality")) {
-      quality = options.Get("quality").As<Napi::Number>().Int32Value();
-      if (quality < 0)
-        quality = 0;
-      if (quality > 100)
-        quality = 100;
-    }
-
-    if (options.Has("maxDpi")) {
-      maxDpi = options.Get("maxDpi").As<Napi::Number>().Int32Value();
-      if (maxDpi < 0)
-        maxDpi = 0;
-    }
+    if (options.Has("lossy"))
+      lossy = options.Get("lossy").As<Napi::Boolean>().Value();
 
     if (options.Has("stripMetadata"))
       stripMeta = options.Get("stripMetadata").As<Napi::Boolean>().Value();
@@ -217,16 +207,16 @@ static Napi::Value Compress(const Napi::CallbackInfo &info) {
   if (info[0].IsBuffer()) {
     auto buf = info[0].As<Napi::Buffer<uint8_t>>();
     std::vector<uint8_t> data(buf.Data(), buf.Data() + buf.Length());
-    auto *worker = new CompressWorker(env, std::move(data), lossy, quality,
-                                      maxDpi, stripMeta, std::move(outputPath));
+    auto *worker = new CompressWorker(env, std::move(data), lossy, stripMeta,
+                                      std::move(outputPath));
     worker->Queue();
     return worker->Promise();
   }
 
   if (info[0].IsString()) {
     auto path = info[0].As<Napi::String>().Utf8Value();
-    auto *worker = new CompressWorker(env, std::move(path), lossy, quality,
-                                      maxDpi, stripMeta, std::move(outputPath));
+    auto *worker = new CompressWorker(env, std::move(path), lossy, stripMeta,
+                                      std::move(outputPath));
     worker->Queue();
     return worker->Promise();
   }