@napi-rs/image 1.0.0

package/.gitattributes

@@ -0,0 +1,13 @@
+# Auto detect text files and perform LF normalization
+*        text=auto
+
+
+*.ts    text eol=lf merge=union 
+*.tsx   text eol=lf merge=union 
+*.rs    text eol=lf merge=union 
+*.js    text eol=lf merge=union 
+*.json  text eol=lf merge=union 
+*.debug text eol=lf merge=union 
+
+index.js linguist-detectable=false
+index.d.ts inguist-detectable=false

package/Cargo.toml

@@ -0,0 +1,35 @@
+[package]
+edition = "2021"
+name = "napi-rs_pngquant"
+version = "0.0.0"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+libc = "0.2"
+napi = {version = "2", default-features = false, features = ["napi3"]}
+napi-derive = {version = "2", default-features = false, features = ["type-def"]}
+
+[target.'cfg(not(any(target_arch = "x86_64", target_arch = "x86", target_arch = "aarch64")))'.dependencies.oxipng]
+default-features = false
+features = ["parallel", "libdeflater"]
+version = "5"
+
+[target.'cfg(any(target_arch = "x86_64", target_arch = "x86", target_arch = "aarch64"))'.dependencies.oxipng]
+default-features = false
+features = ["parallel"]
+version = "5"
+
+[target.'cfg(not(all(target_os = "linux", target_arch = "arm")))'.dependencies.mozjpeg-sys]
+version = "1"
+
+[target.'cfg(all(target_os = "linux", target_arch = "arm"))'.dependencies.mozjpeg-sys]
+default-features = false
+version = "1"
+
+[build-dependencies]
+napi-build = "1"
+
+[profile.release]
+lto = true

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-present LongYinan(github@lyn.one)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,91 @@
+# `@napi-rs/image`
+
+Image processing library.
+
+![CI](https://github.com/Brooooooklyn/image/workflows/CI/badge.svg)
+[![install size](https://packagephobia.com/badge?p=@napi-rs/image)](https://packagephobia.com/result?p=@napi-rs/image)
+[![Downloads](https://img.shields.io/npm/dm/@napi-rs/image.svg?sanitize=true)](https://npmcharts.com/compare/@napi-rs/image?minimal=true)
+
+## Support matrix
+
+|                       | node10 | node12 | node14 | node16 | node17 |
+| --------------------- | ------ | ------ | ------ | ------ | ------ |
+| Windows x64           | ✓      | ✓      | ✓      | ✓      | ✓      |
+| Windows x32           | ✓      | ✓      | ✓      | ✓      | ✓      |
+| macOS x64             | ✓      | ✓      | ✓      | ✓      | ✓      |
+| macOS arm64 (m chips) | ✓      | ✓      | ✓      | ✓      | ✓      |
+| Linux x64 gnu         | ✓      | ✓      | ✓      | ✓      | ✓      |
+| Linux x64 musl        | ✓      | ✓      | ✓      | ✓      | ✓      |
+| Linux arm gnu         | ✓      | ✓      | ✓      | ✓      | ✓      |
+| Linux arm64 gnu       | ✓      | ✓      | ✓      | ✓      | ✓      |
+| Linux arm64 musl      | ✓      | ✓      | ✓      | ✓      | ✓      |
+| Android arm64         | ✓      | ✓      | ✓      | ✓      | ✓      |
+| Android armv7         | ✓      | ✓      | ✓      | ✓      | ✓      |
+| FreeBSD x64           | ✓      | ✓      | ✓      | ✓      | ✓      |
+
+## Lossless compression
+
+### `PNG`
+
+```ts
+export interface PNGLosslessOptions {
+  /**
+   * Attempt to fix errors when decoding the input file rather than returning an Err.
+   * Default: `false`
+   */
+  fixErrors?: boolean | undefined | null
+  /**
+   * Write to output even if there was no improvement in compression.
+   * Default: `false`
+   */
+  force?: boolean | undefined | null
+  /** Which filters to try on the file (0-5) */
+  filter?: Array<number> | undefined | null
+  /**
+   * Whether to attempt bit depth reduction
+   * Default: `true`
+   */
+  bitDepthReduction?: boolean | undefined | null
+  /**
+   * Whether to attempt color type reduction
+   * Default: `true`
+   */
+  colorTypeReduction?: boolean | undefined | null
+  /**
+   * Whether to attempt palette reduction
+   * Default: `true`
+   */
+  paletteReduction?: boolean | undefined | null
+  /**
+   * Whether to attempt grayscale reduction
+   * Default: `true`
+   */
+  grayscaleReduction?: boolean | undefined | null
+  /**
+   * Whether to perform IDAT recoding
+   * If any type of reduction is performed, IDAT recoding will be performed regardless of this setting
+   * Default: `true`
+   */
+  idatRecoding?: boolean | undefined | null
+  /** Whether to remove ***All non-critical headers*** on PNG */
+  strip?: boolean | undefined | null
+  /** Whether to use heuristics to pick the best filter and compression */
+  useHeuristics?: boolean | undefined | null
+}
+export function losslessCompressPng(input: Buffer, options?: PNGLosslessOptions | undefined | null): Buffer
+```
+
+### `JPEG`
+
+```ts
+export interface JpegCompressOptions {
+  /** Output quality, default is 100 (lossless) */
+  quality?: number | undefined | null
+  /**
+   * If true, it will use MozJPEG’s scan optimization. Makes progressive image files smaller.
+   * Default is `true`
+   */
+  optimizeScans?: boolean | undefined | null
+}
+export function compressJpeg(input: Buffer, options?: JpegCompressOptions | undefined | null): Buffer
+```

package/__test__/lossless.spec.mjs

@@ -0,0 +1,18 @@
+import { promises as fs } from 'fs'
+
+import test from 'ava'
+
+import { losslessCompressPng, compressJpeg } from '../index.js'
+
+const PNG = await fs.readFile('un-optimized.png')
+const JPEG = await fs.readFile('un-optimized.jpg')
+
+test('should be able to lossless optimize png image', async (t) => {
+  const dest = losslessCompressPng(PNG)
+  t.true(dest.length < PNG.length)
+})
+
+test('should be able to lossless optimize jpeg image', async (t) => {
+  const dest = compressJpeg(JPEG, { quality: 100 })
+  t.true(dest.length < PNG.length)
+})

package/build.rs

@@ -0,0 +1,5 @@
+extern crate napi_build;
+
+fn main() {
+  napi_build::setup();
+}

package/index.d.ts

@@ -0,0 +1,66 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/* auto-generated by NAPI-RS */
+
+export class ExternalObject<T> {
+  readonly '': {
+    readonly '': unique symbol
+    [K: symbol]: T
+  }
+}
+export interface PNGLosslessOptions {
+  /**
+   * Attempt to fix errors when decoding the input file rather than returning an Err.
+   * Default: `false`
+   */
+  fixErrors?: boolean | undefined | null
+  /**
+   * Write to output even if there was no improvement in compression.
+   * Default: `false`
+   */
+  force?: boolean | undefined | null
+  /** Which filters to try on the file (0-5) */
+  filter?: Array<number> | undefined | null
+  /**
+   * Whether to attempt bit depth reduction
+   * Default: `true`
+   */
+  bitDepthReduction?: boolean | undefined | null
+  /**
+   * Whether to attempt color type reduction
+   * Default: `true`
+   */
+  colorTypeReduction?: boolean | undefined | null
+  /**
+   * Whether to attempt palette reduction
+   * Default: `true`
+   */
+  paletteReduction?: boolean | undefined | null
+  /**
+   * Whether to attempt grayscale reduction
+   * Default: `true`
+   */
+  grayscaleReduction?: boolean | undefined | null
+  /**
+   * Whether to perform IDAT recoding
+   * If any type of reduction is performed, IDAT recoding will be performed regardless of this setting
+   * Default: `true`
+   */
+  idatRecoding?: boolean | undefined | null
+  /** Whether to remove ***All non-critical headers*** on PNG */
+  strip?: boolean | undefined | null
+  /** Whether to use heuristics to pick the best filter and compression */
+  useHeuristics?: boolean | undefined | null
+}
+export function losslessCompressPng(input: Buffer, options?: PNGLosslessOptions | undefined | null): Buffer
+export interface JpegCompressOptions {
+  /** Output quality, default is 100 (lossless) */
+  quality?: number | undefined | null
+  /**
+   * If true, it will use MozJPEG’s scan optimization. Makes progressive image files smaller.
+   * Default is `true`
+   */
+  optimizeScans?: boolean | undefined | null
+}
+export function compressJpeg(input: Buffer, options?: JpegCompressOptions | undefined | null): Buffer

package/index.js

@@ -0,0 +1,209 @@
+const { existsSync, readFileSync } = require('fs')
+const { join } = require('path')
+
+const { platform, arch } = process
+
+let nativeBinding = null
+let localFileExisted = false
+let loadError = null
+
+function isMusl() {
+  // For Node 10
+  if (!process.report || typeof process.report.getReport !== 'function') {
+    try {
+      return readFileSync('/usr/bin/ldd', 'utf8').includes('musl')
+    } catch (e) {
+      return false
+    }
+  } else {
+    const { glibcVersionRuntime } = process.report.getReport().header
+    return !Boolean(glibcVersionRuntime)
+  }
+}
+
+switch (platform) {
+  case 'android':
+    if (arch !== 'arm64') {
+      throw new Error(`Unsupported architecture on Android ${arch}`)
+    }
+    localFileExisted = existsSync(join(__dirname, 'image.android-arm64.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./image.android-arm64.node')
+      } else {
+        nativeBinding = require('@napi-rs/image-android-arm64')
+      }
+    } catch (e) {
+      loadError = e
+    }
+    break
+  case 'win32':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'image.win32-x64-msvc.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./image.win32-x64-msvc.node')
+          } else {
+            nativeBinding = require('@napi-rs/image-win32-x64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'ia32':
+        localFileExisted = existsSync(join(__dirname, 'image.win32-ia32-msvc.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./image.win32-ia32-msvc.node')
+          } else {
+            nativeBinding = require('@napi-rs/image-win32-ia32-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'image.win32-arm64-msvc.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./image.win32-arm64-msvc.node')
+          } else {
+            nativeBinding = require('@napi-rs/image-win32-arm64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Windows: ${arch}`)
+    }
+    break
+  case 'darwin':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'image.darwin-x64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./image.darwin-x64.node')
+          } else {
+            nativeBinding = require('@napi-rs/image-darwin-x64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'image.darwin-arm64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./image.darwin-arm64.node')
+          } else {
+            nativeBinding = require('@napi-rs/image-darwin-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on macOS: ${arch}`)
+    }
+    break
+  case 'freebsd':
+    if (arch !== 'x64') {
+      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`)
+    }
+    localFileExisted = existsSync(join(__dirname, 'image.freebsd-x64.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./image.freebsd-x64.node')
+      } else {
+        nativeBinding = require('@napi-rs/image-freebsd-x64')
+      }
+    } catch (e) {
+      loadError = e
+    }
+    break
+  case 'linux':
+    switch (arch) {
+      case 'x64':
+        if (isMusl()) {
+          localFileExisted = existsSync(join(__dirname, 'image.linux-x64-musl.node'))
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./image.linux-x64-musl.node')
+            } else {
+              nativeBinding = require('@napi-rs/image-linux-x64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(join(__dirname, 'image.linux-x64-gnu.node'))
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./image.linux-x64-gnu.node')
+            } else {
+              nativeBinding = require('@napi-rs/image-linux-x64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm64':
+        if (isMusl()) {
+          localFileExisted = existsSync(join(__dirname, 'image.linux-arm64-musl.node'))
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./image.linux-arm64-musl.node')
+            } else {
+              nativeBinding = require('@napi-rs/image-linux-arm64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(join(__dirname, 'image.linux-arm64-gnu.node'))
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./image.linux-arm64-gnu.node')
+            } else {
+              nativeBinding = require('@napi-rs/image-linux-arm64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(join(__dirname, 'image.linux-arm-gnueabihf.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./image.linux-arm-gnueabihf.node')
+          } else {
+            nativeBinding = require('@napi-rs/image-linux-arm-gnueabihf')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Linux: ${arch}`)
+    }
+    break
+  default:
+    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
+}
+
+if (!nativeBinding) {
+  if (loadError) {
+    throw loadError
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+const { losslessCompressPng, compressJpeg } = nativeBinding
+
+module.exports.losslessCompressPng = losslessCompressPng
+module.exports.compressJpeg = compressJpeg

package/optimize-test.js

@@ -0,0 +1,7 @@
+const { readFileSync, writeFileSync } = require('fs')
+
+const { losslessCompressPng, compressJpeg } = require('./index')
+
+writeFileSync('optimized-lossless.png', losslessCompressPng(readFileSync('./un-optimized.png')))
+
+writeFileSync('optimized-lossless.jpg', compressJpeg(readFileSync('./un-optimized.jpg')))

package/package.json

@@ -0,0 +1,97 @@
+{
+  "name": "@napi-rs/image",
+  "version": "1.0.0",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "description": "Image processing library",
+  "author": {
+    "email": "github@lyn.one",
+    "name": "LongYinan",
+    "url": "https://lyn.one"
+  },
+  "keywords": [
+    "image",
+    "lossless",
+    "compression",
+    "jpeg",
+    "jpg",
+    "png"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "napi": {
+    "name": "image",
+    "triples": {
+      "additional": [
+        "aarch64-apple-darwin",
+        "aarch64-linux-android",
+        "aarch64-unknown-linux-gnu",
+        "aarch64-unknown-linux-musl",
+        "armv7-unknown-linux-gnueabihf",
+        "x86_64-unknown-linux-musl",
+        "x86_64-unknown-freebsd",
+        "i686-pc-windows-msvc",
+        "armv7-linux-androideabi"
+      ]
+    }
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@napi-rs/cli": "^2.2.1",
+    "@types/node": "^17.0.8",
+    "ava": "^4.0.1",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^2.5.1"
+  },
+  "ava": {
+    "extensions": [
+      "mjs"
+    ],
+    "timeout": "3m",
+    "environmentVariables": {
+      "NODE_ENV": "ava"
+    }
+  },
+  "engines": {
+    "node": ">= 10"
+  },
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/Brooooooklyn"
+  },
+  "scripts": {
+    "artifacts": "napi artifacts",
+    "build": "napi build --platform --release",
+    "build:debug": "napi build --platform",
+    "format": "run-p format:prettier format:rs",
+    "format:prettier": "prettier --config ./package.json -w .",
+    "format:rs": "cargo fmt --all",
+    "prepublishOnly": "napi prepublish -t npm",
+    "test": "ava",
+    "version": "napi version"
+  },
+  "prettier": {
+    "printWidth": 120,
+    "semi": false,
+    "trailingComma": "all",
+    "singleQuote": true,
+    "arrowParens": "always"
+  },
+  "repository": "git@github.com:Brooooooklyn/imgquant.git",
+  "optionalDependencies": {
+    "@napi-rs/image-win32-x64-msvc": "1.0.0",
+    "@napi-rs/image-darwin-x64": "1.0.0",
+    "@napi-rs/image-linux-x64-gnu": "1.0.0",
+    "@napi-rs/image-darwin-arm64": "1.0.0",
+    "@napi-rs/image-android-arm64": "1.0.0",
+    "@napi-rs/image-linux-arm64-gnu": "1.0.0",
+    "@napi-rs/image-linux-arm64-musl": "1.0.0",
+    "@napi-rs/image-linux-arm-gnueabihf": "1.0.0",
+    "@napi-rs/image-linux-x64-musl": "1.0.0",
+    "@napi-rs/image-freebsd-x64": "1.0.0",
+    "@napi-rs/image-win32-ia32-msvc": "1.0.0",
+    "@napi-rs/image-android-arm-eabi": "1.0.0"
+  }
+}

package/src/lib.rs

@@ -0,0 +1,185 @@
+#![deny(clippy::all)]
+
+use std::iter::FromIterator;
+
+use napi::{bindgen_prelude::*, JsBuffer};
+use napi_derive::napi;
+
+#[napi(object, js_name = "PNGLosslessOptions")]
+#[derive(Default)]
+pub struct PNGLosslessOptions {
+  /// Attempt to fix errors when decoding the input file rather than returning an Err.
+  /// Default: `false`
+  pub fix_errors: Option<bool>,
+  /// Write to output even if there was no improvement in compression.
+  /// Default: `false`
+  pub force: Option<bool>,
+  /// Which filters to try on the file (0-5)
+  pub filter: Option<Vec<u32>>,
+  /// Whether to attempt bit depth reduction
+  /// Default: `true`
+  pub bit_depth_reduction: Option<bool>,
+  /// Whether to attempt color type reduction
+  /// Default: `true`
+  pub color_type_reduction: Option<bool>,
+  /// Whether to attempt palette reduction
+  /// Default: `true`
+  pub palette_reduction: Option<bool>,
+  /// Whether to attempt grayscale reduction
+  /// Default: `true`
+  pub grayscale_reduction: Option<bool>,
+  /// Whether to perform IDAT recoding
+  /// If any type of reduction is performed, IDAT recoding will be performed regardless of this setting
+  /// Default: `true`
+  pub idat_recoding: Option<bool>,
+  /// Whether to remove ***All non-critical headers*** on PNG
+  pub strip: Option<bool>,
+  /// Whether to use heuristics to pick the best filter and compression
+  pub use_heuristics: Option<bool>,
+}
+
+#[inline(always)]
+fn to_oxipng_options(options: Option<PNGLosslessOptions>) -> oxipng::Options {
+  let opt = options.unwrap_or_default();
+  oxipng::Options {
+    fix_errors: opt.fix_errors.unwrap_or(false),
+    force: opt.force.unwrap_or(false),
+    filter: opt
+      .filter
+      .map(|v| v.into_iter().map(|i| i as u8).collect())
+      .unwrap_or_else(|| oxipng::IndexSet::from_iter(0..5)),
+    bit_depth_reduction: opt.bit_depth_reduction.unwrap_or(true),
+    color_type_reduction: opt.color_type_reduction.unwrap_or(true),
+    palette_reduction: opt.palette_reduction.unwrap_or(true),
+    grayscale_reduction: opt.grayscale_reduction.unwrap_or(true),
+    idat_recoding: opt.idat_recoding.unwrap_or(true),
+    strip: opt
+      .strip
+      .map(|s| {
+        if s {
+          oxipng::Headers::All
+        } else {
+          oxipng::Headers::None
+        }
+      })
+      .unwrap_or(oxipng::Headers::All),
+    use_heuristics: opt.use_heuristics.unwrap_or(true),
+    #[cfg(not(any(target_arch = "x86_64", target_arch = "x86", target_arch = "aarch64")))]
+    deflate: oxipng::Deflaters::Libdeflater,
+    ..Default::default()
+  }
+}
+
+#[napi]
+pub fn lossless_compress_png(input: Buffer, options: Option<PNGLosslessOptions>) -> Result<Buffer> {
+  let output = oxipng::optimize_from_memory(input.as_ref(), &to_oxipng_options(options))
+    .map_err(|err| Error::new(Status::InvalidArg, format!("Optimize failed {}", err)))?;
+  Ok(output.into())
+}
+
+#[napi(object)]
+#[derive(Default)]
+pub struct JpegCompressOptions {
+  /// Output quality, default is 100 (lossless)
+  pub quality: Option<u32>,
+  /// If true, it will use MozJPEG’s scan optimization. Makes progressive image files smaller.
+  /// Default is `true`
+  pub optimize_scans: Option<bool>,
+}
+
+#[napi]
+pub unsafe fn compress_jpeg(
+  env: Env,
+  input: Buffer,
+  options: Option<JpegCompressOptions>,
+) -> Result<JsBuffer> {
+  std::panic::catch_unwind(|| {
+    let opts = options.unwrap_or_default();
+    let mut de_c_info: mozjpeg_sys::jpeg_decompress_struct = std::mem::zeroed();
+    let mut err_handler = create_error_handler();
+    de_c_info.common.err = &mut err_handler;
+    mozjpeg_sys::jpeg_create_decompress(&mut de_c_info);
+    let input_buf = input.as_ref();
+    #[cfg(any(target_os = "windows", target_arch = "arm"))]
+    mozjpeg_sys::jpeg_mem_src(&mut de_c_info, input_buf.as_ptr(), input_buf.len() as u32);
+    #[cfg(not(any(target_os = "windows", target_arch = "arm")))]
+    mozjpeg_sys::jpeg_mem_src(&mut de_c_info, input_buf.as_ptr(), input_buf.len() as u64);
+    let mut compress_c_info: mozjpeg_sys::jpeg_compress_struct = std::mem::zeroed();
+    compress_c_info.optimize_coding = 1;
+    compress_c_info.common.err = &mut err_handler;
+    mozjpeg_sys::jpeg_create_compress(&mut compress_c_info);
+    mozjpeg_sys::jpeg_read_header(&mut de_c_info, 1);
+    let src_coef_arrays = mozjpeg_sys::jpeg_read_coefficients(&mut de_c_info);
+    mozjpeg_sys::jpeg_copy_critical_parameters(&de_c_info, &mut compress_c_info);
+    if let Some(quality) = opts.quality {
+      mozjpeg_sys::jpeg_set_quality(&mut compress_c_info, quality as i32, 0);
+    }
+    if opts.optimize_scans.unwrap_or(true) {
+      mozjpeg_sys::jpeg_c_set_bool_param(
+        &mut compress_c_info,
+        mozjpeg_sys::J_BOOLEAN_PARAM::JBOOLEAN_OPTIMIZE_SCANS,
+        1,
+      );
+    }
+    mozjpeg_sys::jpeg_c_set_int_param(
+      &mut compress_c_info,
+      mozjpeg_sys::J_INT_PARAM::JINT_DC_SCAN_OPT_MODE,
+      0,
+    );
+    let mut buf = std::ptr::null_mut();
+    let mut outsize = 0;
+    mozjpeg_sys::jpeg_mem_dest(&mut compress_c_info, &mut buf, &mut outsize);
+    mozjpeg_sys::jpeg_write_coefficients(&mut compress_c_info, src_coef_arrays);
+    mozjpeg_sys::jpeg_finish_compress(&mut compress_c_info);
+    mozjpeg_sys::jpeg_finish_decompress(&mut de_c_info);
+    env
+      .create_buffer_with_borrowed_data(
+        buf,
+        outsize as usize,
+        (de_c_info, compress_c_info, buf),
+        |(mut input, mut output, buf), _| {
+          mozjpeg_sys::jpeg_destroy_decompress(&mut input);
+          mozjpeg_sys::jpeg_destroy_compress(&mut output);
+          libc::free(buf as *mut std::ffi::c_void);
+        },
+      )
+      .map(|v| v.into_raw())
+  })
+  .map_err(|err| {
+    Error::new(
+      Status::GenericFailure,
+      format!("Compress JPEG failed {:?}", err),
+    )
+  })
+  .and_then(|v| v)
+}
+
+unsafe fn create_error_handler() -> mozjpeg_sys::jpeg_error_mgr {
+  let mut err: mozjpeg_sys::jpeg_error_mgr = std::mem::zeroed();
+  mozjpeg_sys::jpeg_std_error(&mut err);
+  err.error_exit = Some(unwind_error_exit);
+  err.emit_message = Some(silence_message);
+  err
+}
+
+extern "C" fn unwind_error_exit(cinfo: &mut mozjpeg_sys::jpeg_common_struct) {
+  let message = unsafe {
+    let err = cinfo.err.as_ref().unwrap();
+    match err.format_message {
+      Some(fmt) => {
+        let buffer = std::mem::zeroed();
+        fmt(cinfo, &buffer);
+        let len = buffer.iter().take_while(|&&c| c != 0).count();
+        String::from_utf8_lossy(&buffer[..len]).into()
+      }
+      None => format!("libjpeg error: {}", err.msg_code),
+    }
+  };
+  std::panic::resume_unwind(Box::new(message))
+}
+
+extern "C" fn silence_message(
+  _cinfo: &mut mozjpeg_sys::jpeg_common_struct,
+  _level: std::os::raw::c_int,
+) {
+}