qpdf-compress 0.1.3 → 0.2.0

package/README.md

@@ -17,8 +17,11 @@ import { compress } from 'qpdf-compress';
 // lossless — optimize without touching image quality
 const optimized = await compress(pdfBuffer, { mode: 'lossless' });
 
-// lossy — recompress images as JPEG for maximum savings
-const smaller = await compress(pdfBuffer, { mode: 'lossy', quality: 50 });
+// lossy — auto quality, downscale to 75 DPI, strip metadata
+const smaller = await compress(pdfBuffer, { mode: 'lossy' });
+
+// lossy with explicit quality
+const tiny = await compress(pdfBuffer, { mode: 'lossy', quality: 50 });
 ```
 
 ## 💡 Why qpdf-compress?
@@ -28,6 +31,7 @@ const smaller = await compress(pdfBuffer, { mode: 'lossy', quality: 50 });
 - Native C++ — no WASM overhead, no shell-out to CLI tools
 - Non-blocking — all operations run off the main thread via N-API AsyncWorker
 - Multi-pass optimization — image dedup, JPEG Huffman optimization, Flate level 9
+- Smart defaults — DPI downscaling, metadata stripping, adaptive JPEG quality
 
 **🛠️ Developer experience**
 
@@ -52,16 +56,20 @@ const smaller = await compress(pdfBuffer, { mode: 'lossy', quality: 50 });
 
 ### 📊 How it compares
 
-|                           | **qpdf-compress**       | qpdf CLI          | Ghostscript       |
-| ------------------------- | ----------------------- | ----------------- | ----------------- |
-| Integration               | Native Node.js addon    | Shell exec        | Shell exec        |
-| Async I/O                 | ✅ Non-blocking         | ❌ Blocks on exec | ❌ Blocks on exec |
-| Image deduplication       | ✅                      | ❌                | ❌                |
-| JPEG Huffman optimization | ✅ Lossless (libjpeg)   | ❌                | ❌                |
-| Lossy image compression   | ✅ Configurable quality | ❌                | ✅                |
-| PDF repair                | ✅ Automatic            | ✅ Manual flag    | ⚠️ Partial        |
-| License                   | Apache-2.0              | Apache-2.0        | AGPL-3.0 ⚠️       |
-| Dependencies              | None¹                   | System binary     | System binary     |
+|                           | **qpdf-compress**        | qpdf CLI          | Ghostscript       |
+| ------------------------- | ------------------------ | ----------------- | ----------------- |
+| Integration               | Native Node.js addon     | Shell exec        | Shell exec        |
+| Async I/O                 | ✅ Non-blocking          | ❌ Blocks on exec | ❌ Blocks on exec |
+| Image deduplication       | ✅                       | ❌                | ❌                |
+| JPEG Huffman optimization | ✅ Lossless (libjpeg)    | ❌                | ❌                |
+| Lossy image compression   | ✅ Auto or fixed quality | ❌                | ✅                |
+| CMYK → RGB conversion     | ✅ Automatic             | ❌                | ✅                |
+| DPI downscaling           | ✅ Configurable          | ❌                | ✅                |
+| Metadata stripping        | ✅ Default on            | ✅ Manual flag    | ✅                |
+| Unused font removal       | ✅ Automatic             | ❌                | ❌                |
+| PDF repair                | ✅ Automatic             | ✅ Manual flag    | ⚠️ Partial        |
+| License                   | Apache-2.0               | Apache-2.0        | AGPL-3.0 ⚠️       |
+| Dependencies              | None¹                    | System binary     | System binary     |
 
 ¹ QPDF is statically linked — no runtime dependencies. Prebuilt binaries downloaded at install.
 
@@ -111,12 +119,19 @@ import { compress } from 'qpdf-compress';
 // lossless — optimize streams without touching image quality
 const optimized = await compress(pdfBuffer, { mode: 'lossless' });
 
-// lossy — recompress images as JPEG (default quality: 75)
+// lossy — auto quality per image (skips JPEGs ≤ q90, encodes rest at q85)
 const smaller = await compress(pdfBuffer, { mode: 'lossy' });
 
-// lossy with custom quality (1–100)
+// lossy with explicit quality (1–100)
 const tiny = await compress(pdfBuffer, { mode: 'lossy', quality: 50 });
 
+// control DPI downscaling (default: 75, 0 = disabled)
+const highRes = await compress(pdfBuffer, { mode: 'lossless', maxDpi: 150 });
+const noDpi = await compress(pdfBuffer, { mode: 'lossless', maxDpi: 0 });
+
+// keep metadata (stripped by default)
+const withMeta = await compress(pdfBuffer, { mode: 'lossless', stripMetadata: false });
+
 // file path input (avoids copying into memory twice)
 const result = await compress('/path/to/file.pdf', { mode: 'lossless' });
 
@@ -135,27 +150,35 @@ const fixed = await compress(damagedBuffer, { mode: 'lossless' });
 
 Compresses a PDF document. Automatically repairs damaged PDFs.
 
-| Parameter         | Type                    | Description                                        |
-| ----------------- | ----------------------- | -------------------------------------------------- |
-| `input`           | `Buffer \| string`      | PDF data or file path                              |
-| `options.mode`    | `'lossy' \| 'lossless'` | Compression mode                                   |
-| `options.quality` | `number`                | JPEG quality 1–100 (lossy only, default: 75)       |
-| `options.output`  | `string`                | Write to file path instead of returning a `Buffer` |
+| Parameter               | Type                    | Description                                                          |
+| ----------------------- | ----------------------- | -------------------------------------------------------------------- |
+| `input`                 | `Buffer \| string`      | PDF data or file path                                                |
+| `options.mode`          | `'lossy' \| 'lossless'` | Compression mode                                                     |
+| `options.quality`       | `number`                | JPEG quality 1–100 (lossy only). Omit for auto quality (recommended) |
+| `options.maxDpi`        | `number`                | Downscale images exceeding this DPI. Default: `75`. `0` = disabled   |
+| `options.stripMetadata` | `boolean`               | Remove XMP metadata, document info, and thumbnails. Default: `true`  |
+| `options.output`        | `string`                | Write to file path instead of returning a `Buffer`                   |
 
-**Lossless mode:**
+**Both modes:**
 
 - Deduplicates identical images across pages
 - Optimizes embedded JPEG Huffman tables (2–15% savings, zero quality loss)
 - Recompresses all decodable streams with Flate level 9
 - Generates object streams for smaller metadata overhead
-- Removes unreferenced objects
+- Removes unreferenced objects and unused fonts
+- Downscales images exceeding `maxDpi` (default: 75 DPI)
+- Strips XMP metadata, document info, and thumbnails (default: on)
+- Converts CMYK and ICCBased color spaces to RGB
+- Automatically repairs damaged PDFs
 
-**Lossy mode** (in addition to lossless optimizations):
+**Lossy mode** (in addition to the above):
 
-- Extracts 8-bit RGB and grayscale images
-- Recompresses as JPEG at the specified quality
+- Extracts 8-bit RGB, grayscale, and CMYK images
+- **Auto quality** (default): skips existing JPEGs at q ≤ 90, encodes the rest at q85
+- **Explicit quality**: recompresses all images at the specified quality (1–100)
 - Only replaces images where JPEG is actually smaller
-- Skips tiny images (< 50×50 px), CMYK, and indexed color
+- Skips re-encoding when estimated quality is already at or below target
+- Skips tiny images (< 50×50 px)
 
 ## ⚙️ How it works
 

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAe,MAAM,YAAY,CAAC;AAY/D,KAAK,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAC;AAEhC;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,QAAQ,EACf,OAAO,EAAE,eAAe,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GAC5C,OAAO,CAAC,IAAI,CAAC,CAAC;AACjB,wBAAgB,QAAQ,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;AA4BrF,YAAY,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAe,MAAM,YAAY,CAAC;AAY/D,KAAK,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAC;AAEhC;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,QAAQ,EACf,OAAO,EAAE,eAAe,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GAC5C,OAAO,CAAC,IAAI,CAAC,CAAC;AACjB,wBAAgB,QAAQ,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;AAgCrF,YAAY,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -26,13 +26,17 @@ export async function compress(input, options) {
     if (mode !== 'lossy' && mode !== 'lossless') {
         throw new TypeError("Mode must be 'lossy' or 'lossless'");
     }
-    const quality = options.quality ?? 75;
-    if (quality < 1 || quality > 100) {
+    const quality = options.quality ?? 0;
+    if (quality !== 0 && (quality < 1 || quality > 100)) {
         throw new RangeError('Quality must be between 1 and 100');
     }
+    const maxDpi = options.maxDpi ?? 75;
+    const stripMetadata = options.stripMetadata ?? true;
     return addon.compress(input, {
         mode,
         quality,
+        ...(maxDpi > 0 ? { maxDpi } : {}),
+        ...(stripMetadata ? { stripMetadata: true } : {}),
         ...(options.output ? { output: options.output } : {}),
     });
 }

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAGzC,MAAM,OAAO,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC/C,MAAM,SAAS,GAAG,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AAE1D,MAAM,QAAQ,GAAG,OAAO,CAAC,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC;AAC9D,IAAI,OAAO,CAAC,QAAQ,KAAK,OAAO,EAAE,CAAC;IACjC,OAAO,CAAC,GAAG,CAAC,IAAI,GAAG,GAAG,QAAQ,IAAI,OAAO,CAAC,GAAG,CAAC,IAAI,IAAI,EAAE,EAAE,CAAC;AAC7D,CAAC;AAED,MAAM,KAAK,GAAgB,OAAO,CAAC,qCAAqC,CAAC,CAAC;AAmB1E,MAAM,CAAC,KAAK,UAAU,QAAQ,CAAC,KAAe,EAAE,OAAwB;IACtE,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QAC3B,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACvB,MAAM,IAAI,SAAS,CAAC,8BAA8B,CAAC,CAAC;QACtD,CAAC;IACH,CAAC;SAAM,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QACrC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACvB,MAAM,IAAI,SAAS,CAAC,4BAA4B,CAAC,CAAC;QACpD,CAAC;IACH,CAAC;SAAM,CAAC;QACN,MAAM,IAAI,SAAS,CAAC,4CAA4C,CAAC,CAAC;IACpE,CAAC;IACD,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAC1B,IAAI,IAAI,KAAK,OAAO,IAAI,IAAI,KAAK,UAAU,EAAE,CAAC;QAC5C,MAAM,IAAI,SAAS,CAAC,oCAAoC,CAAC,CAAC;IAC5D,CAAC;IACD,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,EAAE,CAAC;IACtC,IAAI,OAAO,GAAG,CAAC,IAAI,OAAO,GAAG,GAAG,EAAE,CAAC;QACjC,MAAM,IAAI,UAAU,CAAC,mCAAmC,CAAC,CAAC;IAC5D,CAAC;IACD,OAAO,KAAK,CAAC,QAAQ,CAAC,KAAK,EAAE;QAC3B,IAAI;QACJ,OAAO;QACP,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACtD,CAA2B,CAAC;AAC/B,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAGzC,MAAM,OAAO,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC/C,MAAM,SAAS,GAAG,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AAE1D,MAAM,QAAQ,GAAG,OAAO,CAAC,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC;AAC9D,IAAI,OAAO,CAAC,QAAQ,KAAK,OAAO,EAAE,CAAC;IACjC,OAAO,CAAC,GAAG,CAAC,IAAI,GAAG,GAAG,QAAQ,IAAI,OAAO,CAAC,GAAG,CAAC,IAAI,IAAI,EAAE,EAAE,CAAC;AAC7D,CAAC;AAED,MAAM,KAAK,GAAgB,OAAO,CAAC,qCAAqC,CAAC,CAAC;AAmB1E,MAAM,CAAC,KAAK,UAAU,QAAQ,CAAC,KAAe,EAAE,OAAwB;IACtE,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QAC3B,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACvB,MAAM,IAAI,SAAS,CAAC,8BAA8B,CAAC,CAAC;QACtD,CAAC;IACH,CAAC;SAAM,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QACrC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACvB,MAAM,IAAI,SAAS,CAAC,4BAA4B,CAAC,CAAC;QACpD,CAAC;IACH,CAAC;SAAM,CAAC;QACN,MAAM,IAAI,SAAS,CAAC,4CAA4C,CAAC,CAAC;IACpE,CAAC;IACD,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAC1B,IAAI,IAAI,KAAK,OAAO,IAAI,IAAI,KAAK,UAAU,EAAE,CAAC;QAC5C,MAAM,IAAI,SAAS,CAAC,oCAAoC,CAAC,CAAC;IAC5D,CAAC;IACD,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,CAAC,CAAC;IACrC,IAAI,OAAO,KAAK,CAAC,IAAI,CAAC,OAAO,GAAG,CAAC,IAAI,OAAO,GAAG,GAAG,CAAC,EAAE,CAAC;QACpD,MAAM,IAAI,UAAU,CAAC,mCAAmC,CAAC,CAAC;IAC5D,CAAC;IACD,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,EAAE,CAAC;IACpC,MAAM,aAAa,GAAG,OAAO,CAAC,aAAa,IAAI,IAAI,CAAC;IACpD,OAAO,KAAK,CAAC,QAAQ,CAAC,KAAK,EAAE;QAC3B,IAAI;QACJ,OAAO;QACP,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACjC,GAAG,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACjD,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACtD,CAA2B,CAAC;AAC/B,CAAC"}

package/dist/types.d.ts

@@ -1,8 +1,12 @@
 export interface CompressOptions {
     /** Compression mode. */
     readonly mode: 'lossy' | 'lossless';
-    /** JPEG quality for lossy mode (1–100). Default: 75. */
+    /** JPEG quality for lossy mode (1–100). When omitted, automatically determines optimal quality per image (capped at 85). */
     readonly quality?: number;
+    /** Maximum image DPI. Images exceeding this are downscaled. 0 = no limit. Default: 75. */
+    readonly maxDpi?: number;
+    /** Remove XMP metadata, document info, and thumbnails. Default: true. */
+    readonly stripMetadata?: boolean;
     /** Write to this file path instead of returning a Buffer. */
     readonly output?: string;
 }
@@ -10,6 +14,8 @@ export interface NativeAddon {
     compress(input: Buffer | string, options: {
         mode: 'lossy' | 'lossless';
         quality: number;
+        maxDpi?: number;
+        stripMetadata?: boolean;
         output?: string;
     }): Promise<Buffer | undefined>;
 }

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../lib/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC9B,wBAAwB;IACxB,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,UAAU,CAAC;IACpC,wDAAwD;IACxD,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,6DAA6D;IAC7D,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CACN,KAAK,EAAE,MAAM,GAAG,MAAM,EACtB,OAAO,EAAE;QAAE,IAAI,EAAE,OAAO,GAAG,UAAU,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,GACxE,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;CAChC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../lib/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC9B,wBAAwB;IACxB,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,UAAU,CAAC;IACpC,4HAA4H;IAC5H,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,0FAA0F;IAC1F,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,yEAAyE;IACzE,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC,6DAA6D;IAC7D,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CACN,KAAK,EAAE,MAAM,GAAG,MAAM,EACtB,OAAO,EAAE;QACP,IAAI,EAAE,OAAO,GAAG,UAAU,CAAC;QAC3B,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,aAAa,CAAC,EAAE,OAAO,CAAC;QACxB,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,GACA,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;CAChC"}

package/lib/index.ts

@@ -46,13 +46,17 @@ export async function compress(input: PdfInput, options: CompressOptions): Promi
   if (mode !== 'lossy' && mode !== 'lossless') {
     throw new TypeError("Mode must be 'lossy' or 'lossless'");
   }
-  const quality = options.quality ?? 75;
-  if (quality < 1 || quality > 100) {
+  const quality = options.quality ?? 0;
+  if (quality !== 0 && (quality < 1 || quality > 100)) {
     throw new RangeError('Quality must be between 1 and 100');
   }
+  const maxDpi = options.maxDpi ?? 75;
+  const stripMetadata = options.stripMetadata ?? true;
   return addon.compress(input, {
     mode,
     quality,
+    ...(maxDpi > 0 ? { maxDpi } : {}),
+    ...(stripMetadata ? { stripMetadata: true } : {}),
     ...(options.output ? { output: options.output } : {}),
   }) as Promise<Buffer | void>;
 }

package/lib/types.ts

@@ -1,8 +1,12 @@
 export interface CompressOptions {
   /** Compression mode. */
   readonly mode: 'lossy' | 'lossless';
-  /** JPEG quality for lossy mode (1–100). Default: 75. */
+  /** JPEG quality for lossy mode (1–100). When omitted, automatically determines optimal quality per image (capped at 85). */
   readonly quality?: number;
+  /** Maximum image DPI. Images exceeding this are downscaled. 0 = no limit. Default: 75. */
+  readonly maxDpi?: number;
+  /** Remove XMP metadata, document info, and thumbnails. Default: true. */
+  readonly stripMetadata?: boolean;
   /** Write to this file path instead of returning a Buffer. */
   readonly output?: string;
 }
@@ -10,6 +14,12 @@ export interface CompressOptions {
 export interface NativeAddon {
   compress(
     input: Buffer | string,
-    options: { mode: 'lossy' | 'lossless'; quality: number; output?: string },
+    options: {
+      mode: 'lossy' | 'lossless';
+      quality: number; // 0 = auto, 1–100 = fixed
+      maxDpi?: number;
+      stripMetadata?: boolean;
+      output?: string;
+    },
   ): Promise<Buffer | undefined>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qpdf-compress",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "Native PDF compression for Node.js, powered by QPDF",
   "license": "Apache-2.0",
   "type": "module",

package/src/images.cc

@@ -1,6 +1,7 @@
 #include "images.h"
 #include "jpeg.h"
 
+#include <algorithm>
 #include <cstdint>
 #include <cstring>
 #include <limits>
@@ -10,95 +11,243 @@
 
 #include <qpdf/Buffer.hh>
 
+// ---------------------------------------------------------------------------
+// Color space helpers
+// ---------------------------------------------------------------------------
+
+// resolves /ColorSpace to component count and whether it's CMYK.
+// returns 0 on unsupported color spaces.
+static int resolveColorSpace(QPDFObjectHandle cs, bool &isCMYK) {
+  isCMYK = false;
+
+  if (cs.isName()) {
+    auto name = cs.getName();
+    if (name == "/DeviceRGB")
+      return 3;
+    if (name == "/DeviceGray")
+      return 1;
+    if (name == "/DeviceCMYK") {
+      isCMYK = true;
+      return 4;
+    }
+    return 0;
+  }
+
+  // ICCBased: [/ICCBased <stream>] — get /N from the ICC profile stream dict
+  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 == 4)
+            isCMYK = true;
+          if (components == 1 || components == 3 || components == 4)
+            return components;
+        }
+      }
+    }
+  }
+
+  return 0;
+}
+
+// naive CMYK → RGB conversion (without ICC profile).
+// uses the standard formula: R = 255 * (1-C) * (1-K), etc.
+static void cmykToRgb(const unsigned char *cmyk, unsigned char *rgb,
+                      size_t pixelCount) {
+  for (size_t i = 0; i < pixelCount; ++i) {
+    double c = cmyk[i * 4 + 0] / 255.0;
+    double m = cmyk[i * 4 + 1] / 255.0;
+    double y = cmyk[i * 4 + 2] / 255.0;
+    double k = cmyk[i * 4 + 3] / 255.0;
+    rgb[i * 3 + 0] =
+        static_cast<unsigned char>(255.0 * (1.0 - c) * (1.0 - k) + 0.5);
+    rgb[i * 3 + 1] =
+        static_cast<unsigned char>(255.0 * (1.0 - m) * (1.0 - k) + 0.5);
+    rgb[i * 3 + 2] =
+        static_cast<unsigned char>(255.0 * (1.0 - y) * (1.0 - k) + 0.5);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Bilinear downscaling
+// ---------------------------------------------------------------------------
+
+static std::vector<uint8_t> bilinearDownscale(const unsigned char *src,
+                                              int srcW, int srcH,
+                                              int components, int dstW,
+                                              int dstH) {
+  std::vector<uint8_t> dst(static_cast<size_t>(dstW) * dstH * components);
+
+  double xRatio = static_cast<double>(srcW) / dstW;
+  double yRatio = static_cast<double>(srcH) / dstH;
+
+  for (int y = 0; y < dstH; ++y) {
+    double srcY = y * yRatio;
+    int y0 = static_cast<int>(srcY);
+    int y1 = std::min(y0 + 1, srcH - 1);
+    double fy = srcY - y0;
+
+    for (int x = 0; x < dstW; ++x) {
+      double srcX = x * xRatio;
+      int x0 = static_cast<int>(srcX);
+      int x1 = std::min(x0 + 1, srcW - 1);
+      double fx = srcX - x0;
+
+      for (int c = 0; c < components; ++c) {
+        double v00 = src[(y0 * srcW + x0) * components + c];
+        double v10 = src[(y0 * srcW + x1) * components + c];
+        double v01 = src[(y1 * srcW + x0) * components + c];
+        double v11 = src[(y1 * srcW + x1) * components + c];
+
+        double val = v00 * (1 - fx) * (1 - fy) + v10 * fx * (1 - fy) +
+                     v01 * (1 - fx) * fy + v11 * fx * fy;
+        dst[(y * dstW + x) * components + c] =
+            static_cast<uint8_t>(std::min(std::max(val + 0.5, 0.0), 255.0));
+      }
+    }
+  }
+
+  return dst;
+}
+
 // ---------------------------------------------------------------------------
 // Image recompression for lossy mode
 // ---------------------------------------------------------------------------
 
-void optimizeImages(QPDF &qpdf, int quality) {
-  forEachImage(
-      qpdf, [&](const std::string &, QPDFObjectHandle xobj, QPDFObjectHandle) {
-        auto dict = xobj.getDict();
+// 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;
+
+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();
+
+    // only handle 8-bit images
+    if (!dict.getKey("/BitsPerComponent").isInteger() ||
+        dict.getKey("/BitsPerComponent").getIntValue() != 8)
+      return;
 
-        // only handle 8-bit images
-        if (!dict.getKey("/BitsPerComponent").isInteger() ||
-            dict.getKey("/BitsPerComponent").getIntValue() != 8)
-          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());
 
-        int width = 0, height = 0, components = 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 || width > 16384 || height > 16384)
+      return;
 
-        if (width <= 0 || height <= 0 || width > 16384 || height > 16384)
-          return;
+    // determine color components via color space resolution
+    bool isCMYK = false;
+    int components = resolveColorSpace(dict.getKey("/ColorSpace"), isCMYK);
+    if (components == 0)
+      return;
 
-        // determine color components
-        auto cs = dict.getKey("/ColorSpace");
-        if (cs.isName()) {
-          if (cs.getName() == "/DeviceRGB")
-            components = 3;
-          else if (cs.getName() == "/DeviceGray")
-            components = 1;
-          else
-            return; // skip CMYK, Lab, etc.
-        } else {
-          return; // skip indexed, ICCBased, etc.
-        }
+    // skip tiny images (logos, icons)
+    if (width * height < 2500)
+      return;
 
-        // skip tiny images (logos, icons)
-        if (width * height < 2500)
-          return;
+    // get fully decoded stream data (raw pixels)
+    std::shared_ptr<Buffer> streamData;
+    try {
+      streamData = xobj.getStreamData(qpdf_dl_all);
+    } catch (...) {
+      return;
+    }
 
-        // get fully decoded stream data (raw pixels)
-        std::shared_ptr<Buffer> streamData;
-        try {
-          streamData = xobj.getStreamData(qpdf_dl_all);
-        } catch (...) {
-          return;
-        }
+    // overflow-safe size calculation
+    auto w = static_cast<size_t>(width);
+    auto h = static_cast<size_t>(height);
+    auto c = static_cast<size_t>(components);
+    if (h > 0 && w > std::numeric_limits<size_t>::max() / h)
+      return;
+    if (c > 0 && (w * h) > std::numeric_limits<size_t>::max() / c)
+      return;
+    size_t expectedSize = w * h * c;
+    if (streamData->getSize() != expectedSize)
+      return;
 
-        // overflow-safe size calculation
-        auto w = static_cast<size_t>(width);
-        auto h = static_cast<size_t>(height);
-        auto c = static_cast<size_t>(components);
-        if (h > 0 && w > std::numeric_limits<size_t>::max() / h)
-          return;
-        if (c > 0 && (w * h) > std::numeric_limits<size_t>::max() / c)
+    // convert CMYK → RGB for JPEG encoding (JPEG doesn't support CMYK
+    // natively in most decoders)
+    const unsigned char *pixels = streamData->getBuffer();
+    std::vector<uint8_t> rgbBuf;
+    int encodeComponents = components;
+    if (isCMYK) {
+      size_t pixelCount = w * h;
+      rgbBuf.resize(pixelCount * 3);
+      cmykToRgb(pixels, rgbBuf.data(), pixelCount);
+      pixels = rgbBuf.data();
+      encodeComponents = 3;
+    }
+
+    auto currentFilter = dict.getKey("/Filter");
+    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.
+    if (isCurrentlyJpeg && !isCMYK) {
+      auto rawData = xobj.getRawStreamData();
+      int existingQ =
+          estimateJpegQuality(rawData->getBuffer(), rawData->getSize());
+      if (autoQuality) {
+        if (existingQ > 0 && existingQ <= kAutoSkipThreshold)
           return;
-        size_t expectedSize = w * h * c;
-        if (streamData->getSize() != expectedSize)
+      } else {
+        // explicit quality: use existing ceiling logic
+        if (existingQ > 0 && existingQ <= targetQuality)
           return;
+      }
+    }
 
-        auto currentFilter = dict.getKey("/Filter");
-        bool isCurrentlyJpeg =
-            currentFilter.isName() && currentFilter.getName() == "/DCTDecode";
+    // encode as JPEG via libjpeg-turbo
+    std::vector<uint8_t> jpegData;
+    if (!encodeJpeg(pixels, width, height, encodeComponents, targetQuality,
+                    jpegData))
+      return;
 
-        // encode as JPEG via libjpeg-turbo
-        std::vector<uint8_t> jpegData;
-        if (!encodeJpeg(streamData->getBuffer(), width, height, components,
-                        quality, 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
-        if (isCurrentlyJpeg) {
-          auto rawData = xobj.getRawStreamData();
-          if (jpegData.size() >= rawData->getSize())
-            return;
-        }
+    // replace stream data with JPEG
+    std::string jpegStr(reinterpret_cast<char *>(jpegData.data()),
+                        jpegData.size());
+    xobj.replaceStreamData(jpegStr, QPDFObjectHandle::newName("/DCTDecode"),
+                           QPDFObjectHandle::newNull());
+
+    // update color space to DeviceRGB if converted from CMYK/ICCBased
+    if (isCMYK || !dict.getKey("/ColorSpace").isName() ||
+        dict.getKey("/ColorSpace").getName() != "/DeviceRGB") {
+      if (encodeComponents == 3)
+        dict.replaceKey("/ColorSpace", QPDFObjectHandle::newName("/DeviceRGB"));
+      else if (encodeComponents == 1)
+        dict.replaceKey("/ColorSpace",
+                        QPDFObjectHandle::newName("/DeviceGray"));
+    }
 
-        // replace stream data with JPEG
-        std::string jpegStr(reinterpret_cast<char *>(jpegData.data()),
-                            jpegData.size());
-        xobj.replaceStreamData(jpegStr, QPDFObjectHandle::newName("/DCTDecode"),
-                               QPDFObjectHandle::newNull());
-
-        // remove FlateDecode-specific params
-        if (dict.hasKey("/DecodeParms"))
-          dict.removeKey("/DecodeParms");
-        if (dict.hasKey("/Predictor"))
-          dict.removeKey("/Predictor");
-      });
+    // remove FlateDecode-specific params
+    if (dict.hasKey("/DecodeParms"))
+      dict.removeKey("/DecodeParms");
+    if (dict.hasKey("/Predictor"))
+      dict.removeKey("/Predictor");
+  });
 }
 
 // ---------------------------------------------------------------------------
@@ -117,7 +266,8 @@ void deduplicateImages(QPDF &qpdf) {
 
   // first pass: collect image objects and hash their raw data
   forEachImage(qpdf, [&](const std::string & /*key*/, QPDFObjectHandle xobj,
-                         QPDFObjectHandle /*xobjects*/) {
+                         QPDFObjectHandle /*xobjects*/,
+                         QPDFPageObjectHelper & /*page*/) {
     auto og = xobj.getObjGen();
     if (seen.count(og))
       return;
@@ -170,12 +320,13 @@ void deduplicateImages(QPDF &qpdf) {
     return;
 
   // third pass: rewrite XObject references to point to canonical objects
-  forEachImage(qpdf, [&](const std::string &key, QPDFObjectHandle xobj,
-                         QPDFObjectHandle xobjects) {
-    auto it = replacements.find(xobj.getObjGen());
-    if (it != replacements.end())
-      xobjects.replaceKey(key, it->second);
-  });
+  forEachImage(qpdf,
+               [&](const std::string &key, QPDFObjectHandle xobj,
+                   QPDFObjectHandle xobjects, QPDFPageObjectHelper & /*page*/) {
+                 auto it = replacements.find(xobj.getObjGen());
+                 if (it != replacements.end())
+                   xobjects.replaceKey(key, it->second);
+               });
 }
 
 // ---------------------------------------------------------------------------
@@ -186,7 +337,8 @@ void optimizeExistingJpegs(QPDF &qpdf) {
   std::set<QPDFObjGen> processed;
 
   forEachImage(qpdf, [&](const std::string & /*key*/, QPDFObjectHandle xobj,
-                         QPDFObjectHandle /*xobjects*/) {
+                         QPDFObjectHandle /*xobjects*/,
+                         QPDFPageObjectHelper & /*page*/) {
     auto og = xobj.getObjGen();
     if (processed.count(og))
       return;
@@ -216,3 +368,229 @@ void optimizeExistingJpegs(QPDF &qpdf) {
     }
   });
 }
+
+// ---------------------------------------------------------------------------
+// DPI-based image downscaling
+// ---------------------------------------------------------------------------
+
+void downscaleImages(QPDF &qpdf, int maxDpi) {
+  if (maxDpi <= 0)
+    return;
+
+  std::set<QPDFObjGen> processed;
+
+  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();
+
+    if (!dict.getKey("/BitsPerComponent").isInteger() ||
+        dict.getKey("/BitsPerComponent").getIntValue() != 8)
+      return;
+
+    int imgW = 0, imgH = 0;
+    if (dict.getKey("/Width").isInteger())
+      imgW = static_cast<int>(dict.getKey("/Width").getIntValue());
+    if (dict.getKey("/Height").isInteger())
+      imgH = static_cast<int>(dict.getKey("/Height").getIntValue());
+
+    if (imgW <= 0 || imgH <= 0)
+      return;
+
+    bool isCMYK = false;
+    int components = resolveColorSpace(dict.getKey("/ColorSpace"), isCMYK);
+    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;
+
+    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;
+    }
+
+    if (pageW <= 0 || pageH <= 0)
+      return;
+
+    // estimate effective DPI (assumes image fills page — conservative)
+    double dpiX = imgW / (pageW / 72.0);
+    double dpiY = imgH / (pageH / 72.0);
+    double effectiveDpi = std::max(dpiX, dpiY);
+
+    if (effectiveDpi <= maxDpi)
+      return;
+
+    // calculate target dimensions
+    double scale = static_cast<double>(maxDpi) / effectiveDpi;
+    int newW = std::max(1, static_cast<int>(imgW * scale + 0.5));
+    int newH = std::max(1, static_cast<int>(imgH * scale + 0.5));
+
+    // not worth downscaling if the reduction is minimal
+    if (newW >= imgW - 1 && newH >= imgH - 1)
+      return;
+
+    // decode pixels
+    std::shared_ptr<Buffer> streamData;
+    try {
+      streamData = xobj.getStreamData(qpdf_dl_all);
+    } catch (...) {
+      return;
+    }
+
+    auto w = static_cast<size_t>(imgW);
+    auto h = static_cast<size_t>(imgH);
+    auto c = static_cast<size_t>(components);
+    if (h > 0 && w > std::numeric_limits<size_t>::max() / h)
+      return;
+    if (c > 0 && (w * h) > std::numeric_limits<size_t>::max() / c)
+      return;
+    if (streamData->getSize() != w * h * c)
+      return;
+
+    const unsigned char *pixels = streamData->getBuffer();
+    int downscaleComponents = components;
+
+    // convert CMYK → RGB before downscaling
+    std::vector<uint8_t> rgbBuf;
+    if (isCMYK) {
+      size_t pixelCount = w * h;
+      rgbBuf.resize(pixelCount * 3);
+      cmykToRgb(pixels, rgbBuf.data(), pixelCount);
+      pixels = rgbBuf.data();
+      downscaleComponents = 3;
+    }
+
+    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)
+      return;
+
+    std::string rawStr(reinterpret_cast<char *>(scaled.data()), scaled.size());
+    xobj.replaceStreamData(rawStr, QPDFObjectHandle::newName("/FlateDecode"),
+                           QPDFObjectHandle::newNull());
+
+    dict.replaceKey("/Width", QPDFObjectHandle::newInteger(newW));
+    dict.replaceKey("/Height", QPDFObjectHandle::newInteger(newH));
+
+    if (isCMYK) {
+      dict.replaceKey("/ColorSpace", QPDFObjectHandle::newName("/DeviceRGB"));
+    }
+
+    // remove predictor params from previous encoding
+    if (dict.hasKey("/DecodeParms"))
+      dict.removeKey("/DecodeParms");
+    if (dict.hasKey("/Predictor"))
+      dict.removeKey("/Predictor");
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Metadata stripping
+// ---------------------------------------------------------------------------
+
+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");
+  }
+
+  // remove embedded thumbnails
+  for (auto &page : QPDFPageDocumentHelper(qpdf).getAllPages()) {
+    auto pageObj = page.getObjectHandle();
+    if (pageObj.hasKey("/Thumb"))
+      pageObj.removeKey("/Thumb");
+  }
+
+  // remove MarkInfo and page labels (optional metadata)
+  if (root.hasKey("/MarkInfo"))
+    root.removeKey("/MarkInfo");
+}
+
+// ---------------------------------------------------------------------------
+// Remove unused font resources
+// ---------------------------------------------------------------------------
+
+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;
+
+    // collect all font names referenced in this page's content stream(s)
+    std::set<std::string> usedFonts;
+
+    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';
+          }
+        }
+      }
+
+      // 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);
+      }
+    } 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);
+    }
+  }
+}

package/src/images.h

@@ -3,8 +3,10 @@
 #include <qpdf/QPDF.hh>
 #include <qpdf/QPDFObjectHandle.hh>
 #include <qpdf/QPDFPageDocumentHelper.hh>
+#include <qpdf/QPDFPageObjectHelper.hh>
 
-// iterates all image XObjects across all pages
+// iterates all image XObjects across all pages, providing the page helper for
+// context (e.g. MediaBox for DPI calculations)
 template <typename Fn> void forEachImage(QPDF &qpdf, Fn &&fn) {
   for (auto &page : QPDFPageDocumentHelper(qpdf).getAllPages()) {
     auto resources = page.getObjectHandle().getKey("/Resources");
@@ -21,11 +23,20 @@ template <typename Fn> void forEachImage(QPDF &qpdf, Fn &&fn) {
       if (!dict.getKey("/Subtype").isName() ||
           dict.getKey("/Subtype").getName() != "/Image")
         continue;
-      fn(key, xobj, xobjects);
+      fn(key, xobj, xobjects, page);
     }
   }
 }
 
-void optimizeImages(QPDF &qpdf, int quality);
+struct CompressOptions {
+  int quality = 0; // 0 = auto (per-image quality, capped at 85)
+  int maxDpi = 0;  // 0 = no downscaling
+  bool stripMetadata = false;
+};
+
+void optimizeImages(QPDF &qpdf, const CompressOptions &opts);
+void downscaleImages(QPDF &qpdf, int maxDpi);
 void deduplicateImages(QPDF &qpdf);
 void optimizeExistingJpegs(QPDF &qpdf);
+void stripMetadata(QPDF &qpdf);
+void removeUnusedFonts(QPDF &qpdf);

package/src/jpeg.cc

@@ -1,6 +1,7 @@
 #include "jpeg.h"
 
 #include <cstdlib>
+#include <limits>
 
 void jpegErrorExit(j_common_ptr cinfo) {
   auto *myerr = reinterpret_cast<JpegErrorMgr *>(cinfo->err);
@@ -142,3 +143,85 @@ bool encodeJpeg(const unsigned char *pixels, int width, int height,
   free(outbuf);
   return ok;
 }
+
+// ---------------------------------------------------------------------------
+// JPEG quality estimation from quantization tables
+// ---------------------------------------------------------------------------
+
+// standard IJG luminance quantization table (quality 50 baseline)
+static const unsigned int std_luminance_qt[64] = {
+    16, 11, 10, 16, 24,  40,  51,  61,  12, 12, 14, 19, 26,  58,  60,  55,
+    14, 13, 16, 24, 40,  57,  69,  56,  14, 17, 22, 29, 51,  87,  80,  62,
+    18, 22, 37, 56, 68,  109, 103, 77,  24, 35, 55, 64, 81,  104, 113, 92,
+    49, 64, 78, 87, 103, 121, 120, 101, 72, 92, 95, 98, 112, 100, 103, 99};
+
+// isolated setjmp scope for reading JPEG header
+static int estimateJpegQualityImpl(const unsigned char *data, size_t size) {
+  struct jpeg_decompress_struct cinfo = {};
+  JpegErrorMgr jerr = {};
+
+  cinfo.err = jpeg_std_error(&jerr.pub);
+  jerr.pub.error_exit = jpegErrorExit;
+
+  if (setjmp(jerr.jmpbuf)) {
+    jpeg_destroy_decompress(&cinfo);
+    return -1;
+  }
+
+  jpeg_create_decompress(&cinfo);
+  jpeg_mem_src(&cinfo, data, static_cast<unsigned long>(size));
+
+  if (jpeg_read_header(&cinfo, TRUE) != JPEG_HEADER_OK) {
+    jpeg_destroy_decompress(&cinfo);
+    return -1;
+  }
+
+  // need at least the luminance table (slot 0)
+  if (!cinfo.quant_tbl_ptrs[0]) {
+    jpeg_destroy_decompress(&cinfo);
+    return -1;
+  }
+
+  // reverse-engineer the IJG quality from the luminance table.
+  // for each quality q, IJG computes: scale = (q < 50) ? 5000/q : 200-2*q
+  // then each table value = clamp(floor((base * scale + 50) / 100), 1, 255)
+  // we find q that minimizes the sum of absolute differences.
+  JQUANT_TBL *tbl = cinfo.quant_tbl_ptrs[0];
+  int bestQ = -1;
+  long bestError = std::numeric_limits<long>::max();
+
+  for (int q = 1; q <= 100; q++) {
+    long scale = (q < 50) ? 5000L / q : 200L - 2L * q;
+    long error = 0;
+    for (int i = 0; i < 64; i++) {
+      long expected =
+          (static_cast<long>(std_luminance_qt[i]) * scale + 50L) / 100L;
+      if (expected < 1)
+        expected = 1;
+      if (expected > 255)
+        expected = 255;
+      long diff = static_cast<long>(tbl->quantval[i]) - expected;
+      error += (diff < 0) ? -diff : diff;
+    }
+    if (error < bestError) {
+      bestError = error;
+      bestQ = q;
+    }
+    // perfect match — stop early
+    if (error == 0)
+      break;
+  }
+
+  jpeg_destroy_decompress(&cinfo);
+
+  // if the best match is poor (avg > 2 per coefficient), the tables are
+  // non-standard — return -1 to signal we can't reliably estimate
+  if (bestError > 128)
+    return -1;
+
+  return bestQ;
+}
+
+int estimateJpegQuality(const unsigned char *data, size_t size) {
+  return estimateJpegQualityImpl(data, size);
+}

package/src/jpeg.h

@@ -24,3 +24,7 @@ bool losslessJpegOptimize(const unsigned char *data, size_t size,
 // encodes raw pixels as JPEG at the given quality (1–100) via libjpeg-turbo
 bool encodeJpeg(const unsigned char *pixels, int width, int height,
                 int components, int quality, std::vector<uint8_t> &out);
+
+// estimates the IJG quality factor (1–100) from a JPEG's quantization tables.
+// returns -1 if the quality cannot be determined (corrupt, non-standard tables)
+int estimateJpegQuality(const unsigned char *data, size_t size);

package/src/qpdf_addon.cc

@@ -51,17 +51,20 @@ class CompressWorker : public Napi::AsyncWorker {
 public:
   // buffer variant
   CompressWorker(Napi::Env env, std::vector<uint8_t> data, bool lossy,
-                 int quality, std::string outputPath)
+                 int quality, int maxDpi, bool stripMeta,
+                 std::string outputPath)
       : Napi::AsyncWorker(env), deferred_(Napi::Promise::Deferred::New(env)),
         bufferData_(std::move(data)), lossy_(lossy), quality_(quality),
-        useFile_(false), outputPath_(std::move(outputPath)) {}
+        maxDpi_(maxDpi), stripMeta_(stripMeta), useFile_(false),
+        outputPath_(std::move(outputPath)) {}
 
   // file path variant
   CompressWorker(Napi::Env env, std::string path, bool lossy, int quality,
-                 std::string outputPath)
+                 int maxDpi, bool stripMeta, std::string outputPath)
       : Napi::AsyncWorker(env), deferred_(Napi::Promise::Deferred::New(env)),
         filePath_(std::move(path)), lossy_(lossy), quality_(quality),
-        useFile_(true), outputPath_(std::move(outputPath)) {}
+        maxDpi_(maxDpi), stripMeta_(stripMeta), useFile_(true),
+        outputPath_(std::move(outputPath)) {}
 
   Napi::Promise Promise() { return deferred_.Promise(); }
 
@@ -90,9 +93,17 @@ protected:
       }
 
       deduplicateImages(qpdf);
-      if (lossy_)
-        optimizeImages(qpdf, quality_);
+      if (lossy_) {
+        CompressOptions opts;
+        opts.quality = quality_;
+        optimizeImages(qpdf, opts);
+      }
+      if (maxDpi_ > 0)
+        downscaleImages(qpdf, maxDpi_);
       optimizeExistingJpegs(qpdf);
+      removeUnusedFonts(qpdf);
+      if (stripMeta_)
+        stripMetadata(qpdf);
 
       Pl_Flate::setCompressionLevel(9);
 
@@ -143,6 +154,8 @@ private:
   std::string filePath_;
   bool lossy_;
   int quality_;
+  int maxDpi_;
+  bool stripMeta_;
   bool useFile_;
   std::string outputPath_;
   std::vector<uint8_t> result_;
@@ -162,7 +175,9 @@ static Napi::Value Compress(const Napi::CallbackInfo &info) {
   }
 
   bool lossy = false;
-  int quality = 75;
+  int quality = 0;
+  int maxDpi = 0;
+  bool stripMeta = false;
   std::string outputPath;
 
   if (info.Length() >= 2 && info[1].IsObject()) {
@@ -180,12 +195,21 @@ static Napi::Value Compress(const Napi::CallbackInfo &info) {
 
     if (options.Has("quality")) {
       quality = options.Get("quality").As<Napi::Number>().Int32Value();
-      if (quality < 1)
-        quality = 1;
+      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("stripMetadata"))
+      stripMeta = options.Get("stripMetadata").As<Napi::Boolean>().Value();
+
     if (options.Has("output"))
       outputPath = options.Get("output").As<Napi::String>().Utf8Value();
   }
@@ -194,7 +218,7 @@ static Napi::Value Compress(const Napi::CallbackInfo &info) {
     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,
-                                      std::move(outputPath));
+                                      maxDpi, stripMeta, std::move(outputPath));
     worker->Queue();
     return worker->Promise();
   }
@@ -202,7 +226,7 @@ static Napi::Value Compress(const Napi::CallbackInfo &info) {
   if (info[0].IsString()) {
     auto path = info[0].As<Napi::String>().Utf8Value();
     auto *worker = new CompressWorker(env, std::move(path), lossy, quality,
-                                      std::move(outputPath));
+                                      maxDpi, stripMeta, std::move(outputPath));
     worker->Queue();
     return worker->Promise();
   }