High performance self-hosted photo and video management solution.
TypeScript backup-toolfluttergoogle-photosgoogle-photos-alternativejavascriptmobile-appnestjsnodejsphoto-galleryphotosphotos-managementself-hostedsveltesveltekittypescriptvideos
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, LazyLock};
use jxl::api::{
AlphaMode, Endianness, Event, ExtraChannel, JxlColorEncoding, JxlColorProfile, JxlColorType,
JxlDataFormat, JxlDecoder, JxlDecoderOptions, JxlOutputBuffer, JxlParallelRunner,
JxlParallelRunnerFun, JxlPixelFormat, JxlPrimaries, JxlTransferFunction, JxlWhitePoint,
};
use moxcms::{Layout, MatrixCoefficients, Transform16BitExecutor};
use quick_cache::sync::Cache;
use rayon::prelude::*;
use crate::color::{self, CicpColorPrimaries, CicpProfile, Target, TransferCharacteristics};
use crate::image::{Image, Pixels, Samples};
use crate::resize;
/// A JPEG XL image whose header has been read.
pub struct Jxl<'a> {
decoder: JxlDecoder,
input: &'a [u8],
/// The space of the output.
cicp: CicpProfile,
/// Converts wide samples to sRGB when the output is not in the source space.
transform: Option<Arc<Transform16BitExecutor>>,
}
/// Runs on the global pool with up to this many threads, or inline with one.
struct Rayon(usize);
impl JxlParallelRunner for Rayon {
fn run(&mut self, num: usize, fun: &JxlParallelRunnerFun<'_>) -> jxl::error::Result<()> {
(0..num).into_par_iter().try_for_each(fun)
}
fn num_threads(&self) -> usize {
self.0
}
}
/// Stops handing out work once the flag is set.
struct Cancellable<'a> {
pool: Rayon,
cancelled: &'a AtomicBool,
}
impl JxlParallelRunner for Cancellable<'_> {
fn run(&mut self, num: usize, fun: &JxlParallelRunnerFun<'_>) -> jxl::error::Result<()> {
self.pool.run(num, fun)
}
fn num_threads(&self) -> usize {
self.pool.num_threads()
}
// jxl-rs only calls this, and each of its tasks loops many items, so check cancellation here.
fn run_ordered(
&mut self,
num: usize,
max_threads: Option<usize>,
fun: &JxlParallelRunnerFun<'_>,
) -> jxl::error::Result<()> {
self.pool.run_ordered(num, max_threads, &|i| {
if self.cancelled.load(Ordering::Relaxed) {
// Any error stops the decode.
return Err(jxl::error::Error::ApiUsageError("cancelled"));
}
fun(i)
})
}
}
impl<'a> Jxl<'a> {
pub fn open(mut input: &'a [u8], color_space: Target) -> Option<Self> {
let mut options = JxlDecoderOptions::default();
// Colour transforms need straight alpha; premultiplying happens last.
options.alpha_mode = AlphaMode::Unpremultiplied;
let mut decoder = JxlDecoder::new(options);
let Event::BasicInfo = decoder.process(&mut input, None, None).ok()? else {
return None;
};
let extra = decoder.basic_info()?.extra_channels.len();
// An integer pixel format ensures the output profile below is sRGB rather than float scRGB.
decoder
.set_pixel_format(JxlPixelFormat::rgba8(extra))
.ok()?;
let profile = decoder.output_color_profile()?;
if let Some(cicp) = cicp(profile)
&& (color_space == Target::Source || color::is_srgb(cicp))
{
if color::is_hdr(cicp) {
decoder
.set_pixel_format(JxlPixelFormat::rgba16(extra))
.ok()?;
}
return Some(Self {
decoder,
input,
cicp,
transform: None,
});
}
let (transform, layout) = srgb_transform(profile)?;
decoder
.set_pixel_format(JxlPixelFormat {
color_type: match layout {
Layout::GrayAlpha => JxlColorType::GrayscaleAlpha,
_ => JxlColorType::Rgba,
},
color_data_format: Some(JxlDataFormat::U16 {
endianness: Endianness::native(),
bit_depth: 12,
}),
extra_channel_format: vec![None; extra],
})
.ok()?;
Some(Self {
decoder,
input,
cicp: color::SRGB,
transform: Some(transform),
})
}
/// Decodes the first frame unless cancelled, downscaled to cover `target_size` pixels and to
/// fit within `max_pixel_size`.
pub fn decode(
mut self,
target_size: Option<(usize, usize)>,
max_pixel_size: usize,
cancelled: &AtomicBool,
) -> Option<Image> {
let info = self.decoder.basic_info()?;
let (w, h) = info.size;
let alpha = info
.extra_channels
.iter()
.any(|ec| ec.ec_type == ExtraChannel::Alpha);
let format = self.decoder.current_pixel_format()?;
let pixel_bytes =
format.color_type.samples_per_pixel() * format.color_data_format?.bytes_per_sample();
let stride = w.checked_mul(pixel_bytes)?;
let size = resize::cover((w, h), target_size, max_pixel_size);
let samples = if color::is_hdr(self.cicp) {
let mut rgba = Pixels::zeroed(w, h, pixel_bytes)?;
self.decode_frame(&mut rgba, stride, cancelled)?;
Samples::U16(rgba.premultiply_resize(alpha, size)?)
} else {
// The buffer is sized for the wide decode and ends up holding the RGBA8 result at its
// front.
let mut rgba = Pixels::zeroed(w, h, pixel_bytes)?;
self.decode_frame(&mut rgba, stride, cancelled)?;
if let Some(transform) = &self.transform {
color::convert_bands(transform.as_ref(), &mut rgba, stride, cancelled)?;
}
Samples::U8(rgba.premultiply_resize(alpha, size)?)
};
Some(Image {
cicp: self.cicp,
samples,
})
}
fn decode_frame<T>(
&mut self,
rgba: &mut Pixels<T>,
stride: usize,
cancelled: &AtomicBool,
) -> Option<()> {
let (w, h) = (rgba.width(), rgba.height());
let buf = rgba.bytes_mut();
// The pool only pays off for large images, since thumbs are already decoded in parallel.
let threads = if w * h > 512 * 512 {
rayon::current_num_threads()
} else {
1
};
let mut runner = Cancellable {
pool: Rayon(threads),
cancelled,
};
loop {
let output = &mut [JxlOutputBuffer::new(buf, h, stride)];
match self
.decoder
.process(&mut self.input, Some(output), Some(&mut runner))
.ok()?
{
Event::FrameHeader => {}
// Resizing costs ~10% of a thumbnail decode, wasted on tiles that scrolled away
// meanwhile.
Event::FrameComplete { .. } => {
return (!cancelled.load(Ordering::Relaxed)).then_some(());
}
_ => return None,
}
}
}
}
/// The space of the decoded samples, if CICP can describe it.
fn cicp(profile: &JxlColorProfile) -> Option<CicpProfile> {
let JxlColorProfile::Simple(encoding) = profile else {
return None;
};
let (primaries, transfer_function) = match encoding {
JxlColorEncoding::RgbColorSpace {
white_point: JxlWhitePoint::D65,
primaries,
transfer_function,
..
} => (primaries, transfer_function),
// Gray samples decode to neutral RGB, which any primaries reproduce.
JxlColorEncoding::GrayscaleColorSpace {
white_point: JxlWhitePoint::D65,
transfer_function,
..
} => (&JxlPrimaries::SRGB, transfer_function),
_ => return None,
};
Some(CicpProfile {
color_primaries: match primaries {
JxlPrimaries::SRGB => CicpColorPrimaries::Bt709,
JxlPrimaries::BT2100 => CicpColorPrimaries::Bt2020,
JxlPrimaries::P3 => CicpColorPrimaries::Smpte432,
JxlPrimaries::Chromaticities { .. } => return None,
},
transfer_characteristics: match transfer_function {
JxlTransferFunction::SRGB => TransferCharacteristics::Srgb,
JxlTransferFunction::PQ => TransferCharacteristics::Smpte2084,
JxlTransferFunction::HLG => TransferCharacteristics::Hlg,
_ => return None,
},
matrix_coefficients: MatrixCoefficients::Identity,
full_range: true,
})
}
/// Reuse the transform to sRGB for a given source profile.
type Transforms<K> = Cache<K, (Arc<Transform16BitExecutor>, Layout)>;
/// [`color::to_srgb`] for `profile`, built once per distinct profile.
fn srgb_transform(profile: &JxlColorProfile) -> Option<(Arc<Transform16BitExecutor>, Layout)> {
const TRANSFORMS: usize = 8;
static ENCODINGS: LazyLock<Transforms<String>> = LazyLock::new(|| Cache::new(TRANSFORMS));
static ICCS: LazyLock<Transforms<Vec<u8>>> = LazyLock::new(|| Cache::new(TRANSFORMS));
match profile {
JxlColorProfile::Simple(encoding) => ENCODINGS
.get_or_insert_with(&encoding.get_color_encoding_description(), || {
color::to_srgb(&profile.try_as_icc().ok_or(())?).ok_or(())
}),
JxlColorProfile::Icc(icc) => {
ICCS.get_or_insert_with(icc.as_slice(), || color::to_srgb(icc).ok_or(()))
}
}
.ok()
}