@napi-rs/image 1.0.0 → 1.1.2

package/Cargo.toml

@@ -1,35 +0,0 @@
-[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/__test__/lossless.spec.mjs

@@ -1,18 +0,0 @@
-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

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

package/optimize-test.js

@@ -1,7 +0,0 @@
-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/src/lib.rs

@@ -1,185 +0,0 @@
-#![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,
-) {
-}