univert 0.2.0

Universal file converter (library and CLI)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

use std::fs;
use std::path::Path;

use image::ImageFormat;

use crate::{Error, Job, Result, extension_of};

pub fn convert(job: &Job) -> Result<()> {
  let img = image::open(job.input)
    .map_err(|e| Error::other(format!("image decode: {e}")))?;
  save_to(&img, job.output)?;
  Ok(())
}

pub fn from_psd(job: &Job) -> Result<()> {
  let img = load_psd(job.input)?;
  save_to(&img, job.output)?;
  Ok(())
}

pub fn to_jp2(_job: &Job) -> Result<()> {
  // TODO: integrate an encoder (e.g. openjpeg-sys). Until then, declare
  // the feature as not yet implemented so the CLI surfaces a clear error
  // instead of silently failing.
  let from = extension_of(_job.input).unwrap_or_default();
  let to = extension_of(_job.output).unwrap_or_default();
  Err(Error::NotImplemented { from, to })
}

pub fn psd_to_jp2(job: &Job) -> Result<()> {
  to_jp2(job)
}

pub fn from_jp2(job: &Job) -> Result<()> {
  let img = load_jp2(job.input)?;
  save_to(&img, job.output)?;
  Ok(())
}

fn save_to(img: &image::DynamicImage, output: &Path) -> Result<()> {
  let ext = extension_of(output)
    .ok_or_else(|| Error::OutputNoExtension(output.to_path_buf()))?;

  let fmt = match ext.as_str() {
    "bmp" => ImageFormat::Bmp,
    "gif" => ImageFormat::Gif,
    "ico" => ImageFormat::Ico,
    "jpeg" | "jpg" => ImageFormat::Jpeg,
    "png" => ImageFormat::Png,
    "tga" => ImageFormat::Tga,
    "tif" | "tiff" => ImageFormat::Tiff,
    "webp" => ImageFormat::WebP,
    other => {
      return Err(Error::other(format!("no image encoder for .{other}")));
    }
  };

  // ICO only supports up to 256x256; downscale if necessary (mirrors
  // the JS sipsWrapper behavior which capped ICO dimensions).
  let img = if matches!(fmt, ImageFormat::Ico) {
    let (w, h) = (img.width(), img.height());
    if w > 256 || h > 256 {
      img.resize(256, 256, image::imageops::FilterType::Lanczos3)
    } else {
      img.clone()
    }
  } else {
    img.clone()
  };

  img
    .save_with_format(output, fmt)
    .map_err(|e| Error::other(format!("image encode: {e}")))?;
  Ok(())
}

fn load_psd(path: &Path) -> Result<image::DynamicImage> {
  let bytes = fs::read(path)?;
  let psd_doc = psd::Psd::from_bytes(&bytes)
    .map_err(|e| Error::other(format!("psd parse: {e}")))?;
  let rgba = psd_doc.rgba();
  let buf = image::RgbaImage::from_raw(psd_doc.width(), psd_doc.height(), rgba)
    .ok_or_else(|| Error::other("psd: failed to construct RGBA image"))?;
  Ok(image::DynamicImage::ImageRgba8(buf))
}

fn load_jp2(path: &Path) -> Result<image::DynamicImage> {
  let bytes = fs::read(path)?;
  let img = jpeg2k::Image::from_bytes(&bytes)
    .map_err(|e| Error::other(format!("jp2 decode: {e}")))?;
  let dyn_img: image::DynamicImage = (&img)
    .try_into()
    .map_err(|e| Error::other(format!("jp2 convert: {e}")))?;
  Ok(dyn_img)
}