use crate::bit_writer::BitWriter;
use crate::coder_scratch::CoderScratch;
use crate::color::{
ColorTransform, FloatTransferDecoder, RgbBlockTransform, TransferDecoder, TransferLut,
};
use crate::color_encoding::write_color_encoding_with_icc;
use crate::encoding_context::EncodingContext;
use crate::frame::encode_frame;
use crate::gain_map::{EncodedGainMap, GainMap, encode_gain_map};
use crate::image::{Image3F, Image3Si};
use crate::jpeg::BrotliCompression;
use crate::lossless::{encode_frame_lossless, encode_frame_lossless_float, forward_ycocg};
use crate::orientation::Orientation;
use crate::xyb::XybMatrix;
use crate::{ColorEncoding, EncodeError};
use std::num::NonZero;
use std::sync::Arc;
use std::thread::available_parallelism;
fn checked_buffer_size<T>(
width: usize,
height: usize,
channels: usize,
) -> Result<usize, EncodeError> {
let pixel_size = size_of::<T>();
let total_size = width
.checked_mul(height)
.and_then(|v| v.checked_mul(channels));
_ = total_size
.and_then(|v| v.checked_mul(pixel_size))
.and_then(|v| isize::try_from(v).ok())
.map(|v| v as usize)
.ok_or(EncodeError::DimensionTooLarge {
width: height,
height,
})?;
total_size
.and_then(|v| isize::try_from(v).ok())
.map(|v| v as usize)
.ok_or(EncodeError::DimensionTooLarge {
width: height,
height,
})
}
#[derive(Debug, Clone)]
pub(crate) enum AlphaPlane {
U8(Vec<u8>),
U16 { data: Vec<u16>, bits: u8 },
F32(Vec<i32>),
}
const CODESTREAM_MARKER: u8 = 0x0A;
const MIN_DISTANCE: f32 = 0.03;
pub(crate) const MAX_DIMENSION: usize = 0x3FFF_FFFF;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub(crate) enum BitsPerSample {
#[default]
Eight,
Ten,
Twelve,
Sixteen,
F16,
F32,
}
impl BitsPerSample {
pub(crate) fn bits(self) -> u32 {
match self {
BitsPerSample::Eight => 8,
BitsPerSample::Ten => 10,
BitsPerSample::Twelve => 12,
BitsPerSample::Sixteen => 16,
BitsPerSample::F16 => 16,
BitsPerSample::F32 => 32,
}
}
pub(crate) fn is_float(self) -> bool {
matches!(self, BitsPerSample::F16 | BitsPerSample::F32)
}
pub(crate) fn exp_bits(self) -> u32 {
match self {
BitsPerSample::F16 => 5,
BitsPerSample::F32 => 8,
_ => 0,
}
}
}
impl AlphaPlane {
#[inline]
pub(crate) fn from_u8(data: Vec<u8>) -> Self {
Self::U8(data)
}
#[inline]
pub(crate) fn from_u16_10bit(data: Vec<u16>) -> Self {
Self::U16 { data, bits: 10 }
}
#[inline]
pub(crate) fn from_u16_12bit(data: Vec<u16>) -> Self {
Self::U16 { data, bits: 12 }
}
#[inline]
pub(crate) fn from_u16_16bit(data: Vec<u16>) -> Self {
Self::U16 { data, bits: 16 }
}
#[inline]
pub(crate) fn len(&self) -> usize {
match self {
Self::U8(v) => v.len(),
Self::U16 { data, .. } => data.len(),
Self::F32(v) => v.len(),
}
}
#[inline]
pub(crate) fn bits(&self) -> u8 {
match self {
Self::U8(_) => 8,
Self::U16 { bits, .. } => *bits,
Self::F32(_) => 32,
}
}
#[inline]
pub(crate) fn is_float(&self) -> bool {
matches!(self, Self::F32(_))
}
#[inline]
pub(crate) fn get_i32(&self, idx: usize) -> i32 {
match self {
Self::U8(v) => v[idx] as i32,
Self::U16 { data, .. } => data[idx] as i32,
Self::F32(v) => v[idx],
}
}
}
#[derive(Debug, Clone, Copy)]
pub(crate) struct ToneMappingParams {
pub intensity_target: Option<f32>,
pub min_nits: f32,
pub relative_to_max_display: bool,
pub linear_below: f32,
}
impl ToneMappingParams {
fn is_default(&self) -> bool {
self.intensity_target.is_none()
&& self.min_nits == 0.0
&& !self.relative_to_max_display
&& self.linear_below == 0.0
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum Speed {
Fastest,
#[default]
Fast,
Slow,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum DecodingSpeed {
Fastest,
Fast,
#[default]
Slow,
}
impl DecodingSpeed {
pub(crate) fn use_weighted_predictor(self) -> bool {
matches!(self, DecodingSpeed::Slow)
}
pub(crate) fn use_ma_trees(self) -> bool {
!matches!(self, DecodingSpeed::Fastest)
}
}
#[derive(Debug, Clone)]
pub struct EncodeConfig {
pub distance: f32,
pub color_encoding: ColorEncoding,
pub icc_profile: Option<Vec<u8>>,
pub exif: Option<Vec<u8>>,
pub xmp: Option<Vec<u8>>,
pub brotli_compression: Option<Arc<dyn BrotliCompression>>,
pub orientation: Orientation,
pub lossless: bool,
pub progressive: bool,
pub patches: bool,
#[cfg(feature = "splines")]
pub splines: bool,
pub progressive_passes: Option<u32>,
pub progressive_shifts: Option<Vec<u32>>,
pub intensity_target: Option<f32>,
pub min_nits: f32,
pub relative_to_max_display: bool,
pub linear_below: f32,
pub num_threads: usize,
pub speed: Speed,
pub decoding_speed: DecodingSpeed,
pub lossy_modular: LossyModular,
pub gain_map: Option<GainMap>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum LossyModular {
#[default]
Off,
Auto,
Force,
}
#[derive(Debug, Clone)]
pub(crate) struct EncodeConfigImpl {
pub(crate) distance: f32,
pub(crate) color_encoding: ColorEncoding,
pub(crate) icc_profile: Option<Vec<u8>>,
pub(crate) exif: Option<Vec<u8>>,
pub(crate) xmp: Option<Vec<u8>>,
pub(crate) brotli_compression: Option<Arc<dyn BrotliCompression>>,
pub(crate) orientation: Orientation,
pub(crate) alpha: Option<AlphaPlane>,
pub(crate) bits_per_sample: BitsPerSample,
pub(crate) lossless: bool,
pub(crate) progressive: bool,
pub(crate) patches: bool,
#[cfg(feature = "splines")]
pub(crate) splines: bool,
pub(crate) progressive_passes: Option<u32>,
pub(crate) progressive_shifts: Option<Vec<u32>>,
pub(crate) grayscale: bool,
pub(crate) intensity_target: Option<f32>,
pub(crate) min_nits: f32,
pub(crate) relative_to_max_display: bool,
pub(crate) linear_below: f32,
pub(crate) num_threads: usize,
pub(crate) speed: Speed,
pub(crate) decoding_speed: DecodingSpeed,
pub(crate) gain_map: Option<EncodedGainMap>,
}
impl Default for EncodeConfig {
fn default() -> Self {
Self {
distance: 1.0,
color_encoding: ColorEncoding::default(),
icc_profile: None,
exif: None,
xmp: None,
brotli_compression: None,
orientation: Orientation::Normal,
lossless: false,
progressive: false,
patches: false,
#[cfg(feature = "splines")]
splines: false,
progressive_passes: None,
progressive_shifts: None,
intensity_target: None,
min_nits: 0.0,
relative_to_max_display: false,
linear_below: 0.0,
num_threads: available_parallelism()
.unwrap_or(NonZero::new(1).unwrap())
.get(),
speed: Speed::Fast,
decoding_speed: DecodingSpeed::Slow,
lossy_modular: LossyModular::Off,
gain_map: None,
}
}
}
impl Default for EncodeConfigImpl {
fn default() -> Self {
Self {
distance: 1.0,
color_encoding: ColorEncoding::default(),
icc_profile: None,
exif: None,
xmp: None,
brotli_compression: None,
orientation: Orientation::Normal,
alpha: None,
bits_per_sample: BitsPerSample::Eight,
lossless: false,
progressive: false,
patches: false,
#[cfg(feature = "splines")]
splines: false,
grayscale: false,
progressive_passes: None,
progressive_shifts: None,
intensity_target: None,
min_nits: 0.0,
relative_to_max_display: false,
linear_below: 0.0,
num_threads: available_parallelism()
.unwrap_or(NonZero::new(1).unwrap())
.get(),
speed: Speed::Fast,
decoding_speed: DecodingSpeed::Slow,
gain_map: None,
}
}
}
impl EncodeConfigImpl {
pub(crate) fn with_distance(distance: f32) -> Self {
Self {
distance,
..Self::default()
}
}
pub(crate) fn with_num_threads(mut self, n: usize) -> Self {
self.num_threads = n;
self
}
pub(crate) fn with_icc_profile(mut self, icc: Option<Vec<u8>>) -> Self {
self.icc_profile = icc;
self
}
pub(crate) fn with_exif(mut self, exif: Option<Vec<u8>>) -> Self {
self.exif = exif;
self
}
pub(crate) fn with_xmp(mut self, xmp: Option<Vec<u8>>) -> Self {
self.xmp = xmp;
self
}
pub(crate) fn with_brotli_compression(
mut self,
compressor: Option<Arc<dyn BrotliCompression>>,
) -> Self {
self.brotli_compression = compressor;
self
}
pub(crate) fn with_orientation(mut self, orientation: Orientation) -> Self {
self.orientation = orientation;
self
}
pub(crate) fn with_alpha(mut self, alpha: AlphaPlane) -> Self {
self.alpha = Some(alpha);
self
}
pub(crate) fn with_bits_per_sample(mut self, bps: BitsPerSample) -> Self {
self.bits_per_sample = bps;
self
}
pub(crate) fn with_lossless(mut self, lossless: bool) -> Self {
self.lossless = lossless;
self
}
pub(crate) fn with_progressive(mut self, progressive: bool) -> Self {
self.progressive = progressive;
self
}
pub(crate) fn with_patches(mut self, patches: bool) -> Self {
self.patches = patches;
self
}
#[cfg(feature = "splines")]
pub(crate) fn with_splines(mut self, splines: bool) -> Self {
self.splines = splines;
self
}
pub(crate) fn with_progressive_passes(mut self, passes: Option<u32>) -> Self {
self.progressive_passes = passes;
self
}
pub(crate) fn with_progressive_shifts(mut self, shifts: Option<Vec<u32>>) -> Self {
self.progressive_shifts = shifts;
self
}
pub(crate) fn with_progressive_from(self, config: &EncodeConfig) -> Self {
#[cfg(feature = "splines")]
let this = self.with_splines(config.splines);
#[cfg(not(feature = "splines"))]
let this = self;
this.with_progressive(config.progressive)
.with_patches(config.patches)
.with_progressive_passes(config.progressive_passes)
.with_progressive_shifts(config.progressive_shifts.clone())
.with_speed(config.speed)
.with_decoding_speed(config.decoding_speed)
}
pub(crate) fn with_speed(mut self, speed: Speed) -> Self {
self.speed = speed;
self
}
pub(crate) fn with_decoding_speed(mut self, decoding_speed: DecodingSpeed) -> Self {
self.decoding_speed = decoding_speed;
self
}
pub(crate) fn with_grayscale(mut self, grayscale: bool) -> Self {
self.grayscale = grayscale;
self
}
pub(crate) fn with_color_encoding(mut self, enc: ColorEncoding) -> Self {
self.color_encoding = enc;
self
}
pub(crate) fn tone_mapping(&self) -> ToneMappingParams {
ToneMappingParams {
intensity_target: self.intensity_target,
min_nits: self.min_nits,
relative_to_max_display: self.relative_to_max_display,
linear_below: self.linear_below,
}
}
pub(crate) fn with_intensity_target(mut self, nits: Option<f32>) -> Self {
self.intensity_target = nits;
self
}
pub(crate) fn with_gain_map(mut self, gain_map: Option<EncodedGainMap>) -> Self {
self.gain_map = gain_map;
self
}
}
impl EncodeConfig {
pub fn with_distance(mut self, distance: f32) -> Self {
self.distance = distance;
self
}
pub fn with_quality(self, quality: f32) -> Self {
self.with_distance(distance_from_quality(quality))
}
pub fn with_color_encoding(mut self, enc: ColorEncoding) -> Self {
self.color_encoding = enc;
self
}
pub fn with_intensity_target(mut self, nits: f32) -> Self {
self.intensity_target = Some(nits);
self
}
pub fn with_min_nits(mut self, nits: f32) -> Self {
self.min_nits = nits;
self
}
pub fn with_relative_to_max_display(mut self, rel: bool) -> Self {
self.relative_to_max_display = rel;
self
}
pub fn with_linear_below(mut self, v: f32) -> Self {
self.linear_below = v;
self
}
pub(crate) fn tone_mapping(&self) -> ToneMappingParams {
ToneMappingParams {
intensity_target: self.intensity_target,
min_nits: self.min_nits,
relative_to_max_display: self.relative_to_max_display,
linear_below: self.linear_below,
}
}
pub fn with_icc_profile(mut self, icc: Vec<u8>) -> Self {
self.icc_profile = Some(icc);
self
}
pub fn with_exif(mut self, exif: Vec<u8>) -> Self {
self.exif = Some(exif);
self
}
pub fn with_xmp(mut self, xmp: Vec<u8>) -> Self {
self.xmp = Some(xmp);
self
}
pub fn with_brotli_compression(mut self, compressor: Box<dyn BrotliCompression>) -> Self {
self.brotli_compression = Some(Arc::from(compressor));
self
}
pub fn with_orientation(mut self, orientation: Orientation) -> Self {
self.orientation = orientation;
self
}
pub fn with_lossless(mut self, lossless: bool) -> Self {
self.lossless = lossless;
self
}
pub fn with_progressive(mut self, progressive: bool) -> Self {
self.progressive = progressive;
self
}
pub fn with_patches(mut self, patches: bool) -> Self {
self.patches = patches;
self
}
#[cfg(feature = "splines")]
pub fn with_splines(mut self, splines: bool) -> Self {
self.splines = splines;
self
}
pub fn with_lossy_modular(mut self, mode: LossyModular) -> Self {
self.lossy_modular = mode;
self
}
pub fn with_gain_map(mut self, gain_map: GainMap) -> Self {
self.gain_map = Some(gain_map);
self
}
pub fn with_num_threads(mut self, n: usize) -> Self {
self.num_threads = n;
self
}
pub fn with_decoding_speed(mut self, decoding_speed: DecodingSpeed) -> Self {
self.decoding_speed = decoding_speed;
self
}
pub fn with_speed(mut self, speed: Speed) -> Self {
self.speed = speed;
if speed == Speed::Slow {
self.patches = true;
}
self
}
}
pub fn distance_from_quality(quality: f32) -> f32 {
assert!(!quality.is_nan(), "quality must not be NaN");
let q = quality.clamp(0.0, 100.0);
let d = if q >= 99.0 {
0.05 * 2.0f32.powf(100.0 - q)
} else if q >= 90.0 {
10.0f32.powf((99.0 - q) / 9.0 - 1.0)
} else if q >= 30.0 {
0.1 + (100.0 - q) * 0.09
} else {
6.24 + 2.5f32.powf((30.0 - q) / 5.0) / 6.25
};
d.min(25.0)
}
fn apply_yellow_opsin(ctx: &mut EncodingContext, linear: &Image3F, distance: f32) {
if ctx.speed != Speed::Slow {
return;
}
let selection = crate::yellow_opsin::select_yellow(linear, distance);
if let Some(m) = selection.matrix {
ctx.set_xyb_matrix(m, distance, selection.default_channel_weights);
}
ctx.raise_b_qm_scale(selection.b_qm_scale);
}
fn lossy_context(
config: &EncodeConfig,
distance: f32,
xyb: XybMatrix,
pixels: usize,
) -> EncodingContext {
let num_threads = if config.speed == Speed::Fastest {
config.num_threads.min(pixels.div_ceil(64 * 1024).max(1))
} else {
config.num_threads
};
let mut ctx = EncodingContext::new(config.speed, xyb, distance, num_threads);
ctx.lossy_modular = config.lossy_modular;
#[cfg(feature = "splines")]
{
ctx.splines = config.splines
&& config.speed == Speed::Slow
&& config.decoding_speed == DecodingSpeed::Slow;
}
ctx
}
fn for_each_linear_band<F>(
image: &mut Image3F,
ctx: &EncodingContext,
scratch: &mut CoderScratch,
f: F,
) where
F: Fn(usize, [&mut [f32]; 3]) + Sync,
{
let mut pixel_start = 0;
let mut jobs: Vec<_> = image
.row_bands_mut(ctx.thread_pool.num_threads())
.into_iter()
.map(|band| {
let start = pixel_start;
pixel_start += band[0].len();
Some((start, band))
})
.collect();
if jobs.len() <= 1 {
for job in jobs {
let (start, band) = job.unwrap();
f(start, band);
}
} else {
ctx.thread_pool
.steal_for_each_mut(scratch, &mut jobs, |_i, job, _scratch| {
let (start, band) = job.take().unwrap();
f(start, band);
});
}
}
fn linearize_rgb<T, X, const CHANNELS: usize>(
input: &[T],
width: usize,
height: usize,
ctx: &EncodingContext,
scratch: &mut CoderScratch,
transform: &X,
) -> Image3F
where
T: Copy + Sync,
X: RgbBlockTransform<T>,
{
debug_assert!(CHANNELS >= 3);
let mut linear = Image3F::new(width, height);
for_each_linear_band(&mut linear, ctx, scratch, |pixel_start, [r, g, b]| {
let src = &input[pixel_start * CHANNELS..][..r.len() * CHANNELS];
transform.transform_block(src.as_chunks::<CHANNELS>().0, [r, g, b]);
});
linear
}
fn linearize_gray<T, D>(
input: &[T],
width: usize,
height: usize,
ctx: &EncodingContext,
scratch: &mut CoderScratch,
decoder: &D,
) -> Image3F
where
T: Copy + Sync,
D: TransferDecoder<T>,
{
let mut linear = Image3F::new(width, height);
for_each_linear_band(&mut linear, ctx, scratch, |pixel_start, [r, g, b]| {
let src = &input[pixel_start..][..r.len()];
for (((r, g), b), &v) in r
.iter_mut()
.zip(g.iter_mut())
.zip(b.iter_mut())
.zip(src.iter())
{
let linear = decoder.decode(v);
*r = linear;
*g = linear;
*b = linear;
}
});
linear
}
pub fn encode_image(
input: &[u8],
width: usize,
height: usize,
config: &EncodeConfig,
) -> Result<Vec<u8>, EncodeError> {
if width == 0 || height == 0 {
return Err(EncodeError::EmptyImage);
}
if width > MAX_DIMENSION || height > MAX_DIMENSION {
return Err(EncodeError::DimensionTooLarge { width, height });
}
let expected = checked_buffer_size::<u8>(width, height, 3)?;
if input.len() != expected {
return Err(EncodeError::InputSizeMismatch {
expected,
actual: input.len(),
});
}
if !config.distance.is_finite() || config.distance <= 0.0 {
return Err(EncodeError::InvalidDistance(config.distance));
}
if config.lossless {
return encode_with_config_loseless(
input,
width,
height,
false,
8,
&EncodeConfigImpl::with_distance(config.distance)
.with_lossless(config.lossless)
.with_progressive(config.progressive)
.with_patches(config.patches)
.with_icc_profile(config.icc_profile.clone())
.with_exif(config.exif.clone())
.with_gain_map(encode_gain_map(config)?)
.with_xmp(config.xmp.clone())
.with_brotli_compression(config.brotli_compression.clone())
.with_orientation(config.orientation)
.with_color_encoding(config.color_encoding)
.with_intensity_target(config.intensity_target)
.with_speed(config.speed)
.with_decoding_speed(config.decoding_speed)
.with_num_threads(config.num_threads),
);
}
let distance = config.distance.max(MIN_DISTANCE);
let transform = ColorTransform::for_integer(
8,
config.color_encoding.transfer,
config.color_encoding.primaries,
);
let ctx = lossy_context(config, distance, XybMatrix::SPEC, width * height);
let mut scratch = Box::<CoderScratch>::default();
let linear = linearize_rgb::<_, _, 3>(input, width, height, &ctx, &mut scratch, &transform);
let mut ctx = ctx;
apply_yellow_opsin(&mut ctx, &linear, distance);
let cfg = EncodeConfigImpl::with_distance(distance)
.with_progressive_from(config)
.with_icc_profile(config.icc_profile.clone())
.with_exif(config.exif.clone())
.with_gain_map(encode_gain_map(config)?)
.with_xmp(config.xmp.clone())
.with_brotli_compression(config.brotli_compression.clone())
.with_orientation(config.orientation)
.with_color_encoding(config.color_encoding)
.with_intensity_target(config.intensity_target)
.with_num_threads(config.num_threads);
encode_with_context(&linear, &cfg, &ctx, &mut scratch)
}
pub fn encode_image_with_alpha(
input: &[u8],
width: usize,
height: usize,
config: &EncodeConfig,
) -> Result<Vec<u8>, EncodeError> {
if width == 0 || height == 0 {
return Err(EncodeError::EmptyImage);
}
if width > MAX_DIMENSION || height > MAX_DIMENSION {
return Err(EncodeError::DimensionTooLarge { width, height });
}
let expected = checked_buffer_size::<u8>(width, height, 4)?;
if input.len() != expected {
return Err(EncodeError::InputSizeMismatch {
expected,
actual: input.len(),
});
}
if !config.distance.is_finite() || config.distance <= 0.0 {
return Err(EncodeError::InvalidDistance(config.distance));
}
if config.lossless {
return encode_with_config_loseless(
input,
width,
height,
true,
8,
&EncodeConfigImpl::with_distance(config.distance)
.with_lossless(config.lossless)
.with_progressive(config.progressive)
.with_patches(config.patches)
.with_icc_profile(config.icc_profile.clone())
.with_exif(config.exif.clone())
.with_gain_map(encode_gain_map(config)?)
.with_xmp(config.xmp.clone())
.with_brotli_compression(config.brotli_compression.clone())
.with_orientation(config.orientation)
.with_color_encoding(config.color_encoding)
.with_intensity_target(config.intensity_target)
.with_speed(config.speed)
.with_decoding_speed(config.decoding_speed)
.with_num_threads(config.num_threads),
);
}
let distance = config.distance.max(MIN_DISTANCE);
let transform = ColorTransform::for_integer(
8,
config.color_encoding.transfer,
config.color_encoding.primaries,
);
let ctx = lossy_context(config, distance, XybMatrix::SPEC, width * height);
let mut scratch = Box::<CoderScratch>::default();
let linear = linearize_rgb::<_, _, 4>(input, width, height, &ctx, &mut scratch, &transform);
let mut ctx = ctx;
apply_yellow_opsin(&mut ctx, &linear, distance);
let alpha_plane = input.as_chunks::<4>().0.iter().map(|px| px[3]).collect();
let cfg = EncodeConfigImpl::with_distance(distance)
.with_progressive_from(config)
.with_alpha(AlphaPlane::from_u8(alpha_plane))
.with_icc_profile(config.icc_profile.clone())
.with_exif(config.exif.clone())
.with_gain_map(encode_gain_map(config)?)
.with_xmp(config.xmp.clone())
.with_brotli_compression(config.brotli_compression.clone())
.with_orientation(config.orientation)
.with_color_encoding(config.color_encoding)
.with_intensity_target(config.intensity_target)
.with_num_threads(config.num_threads);
encode_with_context(&linear, &cfg, &ctx, &mut scratch)
}
pub fn encode_image_with_alpha_10bit(
input: &[u16],
width: usize,
height: usize,
config: &EncodeConfig,
) -> Result<Vec<u8>, EncodeError> {
encode_high_depth_rgba(input, width, height, true, config, BitsPerSample::Ten)
}
pub fn encode_image_with_alpha_12bit(
input: &[u16],
width: usize,
height: usize,
config: &EncodeConfig,
) -> Result<Vec<u8>, EncodeError> {
encode_high_depth_rgba(input, width, height, true, config, BitsPerSample::Twelve)
}
pub fn encode_image_with_alpha_16bit(
input: &[u16],
width: usize,
height: usize,
config: &EncodeConfig,
) -> Result<Vec<u8>, EncodeError> {
encode_high_depth_rgba(input, width, height, true, config, BitsPerSample::Sixteen)
}
pub fn encode_image_16bit(
input: &[u16],
width: usize,
height: usize,
config: &EncodeConfig,
) -> Result<Vec<u8>, EncodeError> {
encode_high_depth_rgba(input, width, height, false, config, BitsPerSample::Sixteen)
}
pub fn encode_image_10bit(
input: &[u16],
width: usize,
height: usize,
config: &EncodeConfig,
) -> Result<Vec<u8>, EncodeError> {
encode_high_depth_rgba(input, width, height, false, config, BitsPerSample::Ten)
}
pub fn encode_image_12bit(
input: &[u16],
width: usize,
height: usize,
config: &EncodeConfig,
) -> Result<Vec<u8>, EncodeError> {
encode_high_depth_rgba(input, width, height, false, config, BitsPerSample::Twelve)
}
pub fn encode_image_gray(
input: &[u8],
width: usize,
height: usize,
config: &EncodeConfig,
) -> Result<Vec<u8>, EncodeError> {
encode_gray_impl(input, None, width, height, config)
}
pub fn encode_image_gray_alpha(
input: &[u8],
width: usize,
height: usize,
config: &EncodeConfig,
) -> Result<Vec<u8>, EncodeError> {
let expected = checked_buffer_size::<u8>(width, height, 2)?;
if input.len() != expected {
return Err(EncodeError::InputSizeMismatch {
expected: width * height * 2,
actual: input.len(),
});
}
let (luma, alpha): (Vec<u8>, Vec<u8>) = input
.as_chunks::<2>()
.0
.iter()
.map(|px| (px[0], px[1]))
.unzip();
encode_gray_impl(&luma, Some(alpha), width, height, config)
}
fn encode_gray_impl(
luma: &[u8],
alpha: Option<Vec<u8>>,
width: usize,
height: usize,
config: &EncodeConfig,
) -> Result<Vec<u8>, EncodeError> {
if width == 0 || height == 0 {
return Err(EncodeError::EmptyImage);
}
if width > MAX_DIMENSION || height > MAX_DIMENSION {
return Err(EncodeError::DimensionTooLarge { width, height });
}
let expected = checked_buffer_size::<u8>(width, height, 1)?;
if luma.len() != expected {
return Err(EncodeError::InputSizeMismatch {
expected: width * height,
actual: luma.len(),
});
}
if !config.distance.is_finite() || config.distance <= 0.0 {
return Err(EncodeError::InvalidDistance(config.distance));
}
if config.lossless {
let mut image = Image3Si::try_new_per_plane([(width, height), (0, 0), (0, 0)])?;
for (out, &value) in image.plane_mut(0).as_mut_slice().iter_mut().zip(luma) {
*out = value.to_signed_int(8);
}
let alpha_plane = alpha.map(AlphaPlane::U8);
return encode_lossless_planes(
&image,
&alpha_plane,
8,
&EncodeConfigImpl::with_distance(config.distance)
.with_lossless(true)
.with_grayscale(true)
.with_patches(config.patches)
.with_icc_profile(config.icc_profile.clone())
.with_exif(config.exif.clone())
.with_gain_map(encode_gain_map(config)?)
.with_xmp(config.xmp.clone())
.with_brotli_compression(config.brotli_compression.clone())
.with_orientation(config.orientation)
.with_color_encoding(config.color_encoding)
.with_intensity_target(config.intensity_target)
.with_speed(config.speed)
.with_decoding_speed(config.decoding_speed)
.with_num_threads(config.num_threads),
);
}
let distance = config.distance.max(MIN_DISTANCE);
let decoder = TransferLut::new(8, config.color_encoding.transfer);
let ctx = lossy_context(config, distance, XybMatrix::SPEC, width * height);
let mut scratch = Box::<CoderScratch>::default();
let linear = linearize_gray(luma, width, height, &ctx, &mut scratch, &decoder);
let mut cfg = EncodeConfigImpl::with_distance(distance)
.with_progressive_from(config)
.with_grayscale(true)
.with_icc_profile(config.icc_profile.clone())
.with_exif(config.exif.clone())
.with_gain_map(encode_gain_map(config)?)
.with_xmp(config.xmp.clone())
.with_brotli_compression(config.brotli_compression.clone())
.with_orientation(config.orientation)
.with_color_encoding(config.color_encoding)
.with_intensity_target(config.intensity_target)
.with_num_threads(config.num_threads);
if let Some(a) = alpha {
cfg = cfg.with_alpha(AlphaPlane::from_u8(a));
}
encode_with_context(&linear, &cfg, &ctx, &mut scratch)
}
pub fn encode_image_gray_10bit(
input: &[u16],
width: usize,
height: usize,
config: &EncodeConfig,
) -> Result<Vec<u8>, EncodeError> {
encode_gray_high_depth_impl(input, None, width, height, config, BitsPerSample::Ten)
}
pub fn encode_image_gray_12bit(
input: &[u16],
width: usize,
height: usize,
config: &EncodeConfig,
) -> Result<Vec<u8>, EncodeError> {
encode_gray_high_depth_impl(input, None, width, height, config, BitsPerSample::Twelve)
}
pub fn encode_image_gray_alpha_10bit(
input: &[u16],
width: usize,
height: usize,
config: &EncodeConfig,
) -> Result<Vec<u8>, EncodeError> {
let expected = checked_buffer_size::<u16>(width, height, 2)?;
if input.len() != expected {
return Err(EncodeError::InputSizeMismatch {
expected: width * height * 2,
actual: input.len(),
});
}
let (luma, alpha): (Vec<u16>, Vec<u16>) = input
.as_chunks::<2>()
.0
.iter()
.map(|px| (px[0], px[1]))
.unzip();
encode_gray_high_depth_impl(
&luma,
Some(alpha),
width,
height,
config,
BitsPerSample::Ten,
)
}
pub fn encode_image_gray_alpha_12bit(
input: &[u16],
width: usize,
height: usize,
config: &EncodeConfig,
) -> Result<Vec<u8>, EncodeError> {
let expected = checked_buffer_size::<u16>(width, height, 2)?;
if input.len() != expected {
return Err(EncodeError::InputSizeMismatch {
expected: width * height * 2,
actual: input.len(),
});
}
let (luma, alpha): (Vec<u16>, Vec<u16>) = input
.as_chunks::<2>()
.0
.iter()
.map(|px| (px[0], px[1]))
.unzip();
encode_gray_high_depth_impl(
&luma,
Some(alpha),
width,
height,
config,
BitsPerSample::Twelve,
)
}
pub fn encode_image_gray_16bit(
input: &[u16],
width: usize,
height: usize,
config: &EncodeConfig,
) -> Result<Vec<u8>, EncodeError> {
encode_gray_high_depth_impl(input, None, width, height, config, BitsPerSample::Sixteen)
}
pub fn encode_image_gray_alpha_16bit(
input: &[u16],
width: usize,
height: usize,
config: &EncodeConfig,
) -> Result<Vec<u8>, EncodeError> {
let expected = checked_buffer_size::<u16>(width, height, 2)?;
if input.len() != expected {
return Err(EncodeError::InputSizeMismatch {
expected: width * height * 2,
actual: input.len(),
});
}
let (luma, alpha): (Vec<u16>, Vec<u16>) = input
.as_chunks::<2>()
.0
.iter()
.map(|px| (px[0], px[1]))
.unzip();
encode_gray_high_depth_impl(
&luma,
Some(alpha),
width,
height,
config,
BitsPerSample::Sixteen,
)
}
fn encode_gray_high_depth_impl(
luma: &[u16],
alpha: Option<Vec<u16>>,
width: usize,
height: usize,
config: &EncodeConfig,
bps: BitsPerSample,
) -> Result<Vec<u8>, EncodeError> {
if width == 0 || height == 0 {
return Err(EncodeError::EmptyImage);
}
if width > MAX_DIMENSION || height > MAX_DIMENSION {
return Err(EncodeError::DimensionTooLarge { width, height });
}
let expected = checked_buffer_size::<u16>(width, height, 1)?;
if luma.len() != expected {
return Err(EncodeError::InputSizeMismatch {
expected: width * height,
actual: luma.len(),
});
}
if let Some(alpha) = alpha.as_ref()
&& alpha.len() != expected
{
return Err(EncodeError::InputSizeMismatch {
expected: width * height,
actual: luma.len(),
});
}
if !config.distance.is_finite() || config.distance <= 0.0 {
return Err(EncodeError::InvalidDistance(config.distance));
}
if config.lossless {
let mut image = Image3Si::try_new_per_plane([(width, height), (0, 0), (0, 0)])?;
for (out, &value) in image.plane_mut(0).as_mut_slice().iter_mut().zip(luma) {
*out = value.to_signed_int(bps.bits() as u8);
}
let alpha_plane = alpha.map(|mut data| {
let bits = bps.bits() as u8;
for value in &mut data {
*value = (*value).to_signed_int(bits) as u16;
}
AlphaPlane::U16 { data, bits }
});
return encode_lossless_planes(
&image,
&alpha_plane,
bps.bits() as u8,
&EncodeConfigImpl::with_distance(config.distance)
.with_lossless(true)
.with_grayscale(true)
.with_patches(config.patches)
.with_bits_per_sample(bps)
.with_icc_profile(config.icc_profile.clone())
.with_exif(config.exif.clone())
.with_gain_map(encode_gain_map(config)?)
.with_xmp(config.xmp.clone())
.with_brotli_compression(config.brotli_compression.clone())
.with_orientation(config.orientation)
.with_color_encoding(config.color_encoding)
.with_intensity_target(config.intensity_target)
.with_speed(config.speed)
.with_decoding_speed(config.decoding_speed)
.with_num_threads(config.num_threads),
);
}
let distance = config.distance.max(MIN_DISTANCE);
let decoder = TransferLut::new(bps.bits(), config.color_encoding.transfer);
let ctx = lossy_context(config, distance, XybMatrix::SPEC, width * height);
let mut scratch = Box::<CoderScratch>::default();
let linear = linearize_gray(luma, width, height, &ctx, &mut scratch, &decoder);
let alpha_plane = alpha.map(|a| match bps {
BitsPerSample::Ten => AlphaPlane::from_u16_10bit(a),
BitsPerSample::Twelve => AlphaPlane::from_u16_12bit(a),
BitsPerSample::Sixteen => AlphaPlane::from_u16_16bit(a),
BitsPerSample::Eight => unreachable!("high-depth gray path called with 8-bit bps"),
BitsPerSample::F16 | BitsPerSample::F32 => {
unreachable!("float path does not use the integer alpha match")
}
});
let mut cfg = EncodeConfigImpl::with_distance(distance)
.with_progressive_from(config)
.with_grayscale(true)
.with_bits_per_sample(bps)
.with_icc_profile(config.icc_profile.clone())
.with_exif(config.exif.clone())
.with_gain_map(encode_gain_map(config)?)
.with_xmp(config.xmp.clone())
.with_brotli_compression(config.brotli_compression.clone())
.with_orientation(config.orientation)
.with_color_encoding(config.color_encoding)
.with_intensity_target(config.intensity_target)
.with_num_threads(config.num_threads);
if let Some(ap) = alpha_plane {
cfg = cfg.with_alpha(ap);
}
encode_with_context(&linear, &cfg, &ctx, &mut scratch)
}
fn encode_high_depth_rgba(
input: &[u16],
width: usize,
height: usize,
has_alpha: bool,
config: &EncodeConfig,
bps: BitsPerSample,
) -> Result<Vec<u8>, EncodeError> {
let expected = checked_buffer_size::<u16>(width, height, if has_alpha { 4 } else { 3 })?;
if input.len() != expected {
return Err(EncodeError::InputSizeMismatch {
expected,
actual: input.len(),
});
}
if config.lossless {
return encode_with_config_loseless(
input,
width,
height,
has_alpha,
bps.bits() as u8,
&EncodeConfigImpl::with_distance(config.distance)
.with_lossless(config.lossless)
.with_bits_per_sample(bps)
.with_patches(config.patches)
.with_icc_profile(config.icc_profile.clone())
.with_exif(config.exif.clone())
.with_gain_map(encode_gain_map(config)?)
.with_xmp(config.xmp.clone())
.with_brotli_compression(config.brotli_compression.clone())
.with_orientation(config.orientation)
.with_color_encoding(config.color_encoding)
.with_intensity_target(config.intensity_target)
.with_speed(config.speed)
.with_decoding_speed(config.decoding_speed)
.with_num_threads(config.num_threads),
);
}
let distance = config.distance.max(MIN_DISTANCE);
let transform = ColorTransform::for_integer(
bps.bits(),
config.color_encoding.transfer,
config.color_encoding.primaries,
);
let ctx = lossy_context(config, distance, XybMatrix::SPEC, width * height);
let mut scratch = Box::<CoderScratch>::default();
let bp_max: u16 = if bps.bits() >= 16 {
u16::MAX
} else {
((1u32 << bps.bits()) - 1) as u16
};
if has_alpha {
let linear = linearize_rgb::<_, _, 4>(input, width, height, &ctx, &mut scratch, &transform);
let mut ctx = ctx;
apply_yellow_opsin(&mut ctx, &linear, distance);
let alpha_plane = input
.as_chunks::<4>()
.0
.iter()
.map(|px| px[3].min(bp_max))
.collect();
let cfg = EncodeConfigImpl::with_distance(distance)
.with_progressive_from(config)
.with_alpha(match bps {
BitsPerSample::Ten => AlphaPlane::from_u16_10bit(alpha_plane),
BitsPerSample::Twelve => AlphaPlane::from_u16_12bit(alpha_plane),
BitsPerSample::Sixteen => AlphaPlane::from_u16_16bit(alpha_plane),
BitsPerSample::Eight => unreachable!("high-depth path called with 8-bit bps"),
BitsPerSample::F16 | BitsPerSample::F32 => {
unreachable!("float path does not use the integer alpha match")
}
})
.with_bits_per_sample(bps)
.with_icc_profile(config.icc_profile.clone())
.with_exif(config.exif.clone())
.with_gain_map(encode_gain_map(config)?)
.with_xmp(config.xmp.clone())
.with_brotli_compression(config.brotli_compression.clone())
.with_orientation(config.orientation)
.with_color_encoding(config.color_encoding)
.with_intensity_target(config.intensity_target)
.with_num_threads(config.num_threads);
encode_with_context(&linear, &cfg, &ctx, &mut scratch)
} else {
let linear = linearize_rgb::<_, _, 3>(input, width, height, &ctx, &mut scratch, &transform);
let mut ctx = ctx;
apply_yellow_opsin(&mut ctx, &linear, distance);
let cfg = EncodeConfigImpl::with_distance(distance)
.with_progressive_from(config)
.with_bits_per_sample(bps)
.with_icc_profile(config.icc_profile.clone())
.with_exif(config.exif.clone())
.with_gain_map(encode_gain_map(config)?)
.with_xmp(config.xmp.clone())
.with_brotli_compression(config.brotli_compression.clone())
.with_orientation(config.orientation)
.with_color_encoding(config.color_encoding)
.with_intensity_target(config.intensity_target)
.with_num_threads(config.num_threads);
encode_with_context(&linear, &cfg, &ctx, &mut scratch)
}
}
fn encode_f32_lossless_rgba(
input: &[f32],
width: usize,
height: usize,
has_alpha: bool,
config: &EncodeConfig,
) -> Result<Vec<u8>, EncodeError> {
if width == 0 || height == 0 {
return Err(EncodeError::EmptyImage);
}
if width > MAX_DIMENSION || height > MAX_DIMENSION {
return Err(EncodeError::DimensionTooLarge { width, height });
}
for &v in input.iter() {
if !v.is_finite() || v < 0.0 {
return Err(EncodeError::Unsupported(
"f32 lossless v1 supports only finite non-negative values",
));
}
}
let nchan = if has_alpha { 4 } else { 3 };
let mut image3s = Image3Si::new(width, height);
let mut alpha_bits: Vec<i32> = if has_alpha {
Vec::with_capacity(width * height)
} else {
Vec::new()
};
for (y, row) in input.chunks_exact(width * nchan).enumerate() {
let [r_row, g_row, b_row] = image3s.all_plane_rows_mut(y);
for (x, src) in row.chunks_exact(nchan).enumerate() {
r_row[x] = src[0].to_bits() as i32;
g_row[x] = src[1].to_bits() as i32;
b_row[x] = src[2].to_bits() as i32;
if has_alpha {
alpha_bits.push(src[3].to_bits() as i32);
}
}
}
let alpha = if has_alpha {
Some(AlphaPlane::F32(alpha_bits))
} else {
None
};
let mut w = BitWriter::new();
w.write(8, 0xFF);
w.write(8, CODESTREAM_MARKER as u64);
write_size_header(width, height, &mut w);
{
let mut metadata_scratch = Box::new(CoderScratch::lossless());
write_image_metadata(
config.tone_mapping(),
&config.color_encoding,
alpha.as_ref(),
config.icc_profile.as_deref(),
BitsPerSample::F32,
true,
&XybMatrix::SPEC,
false,
config.orientation,
&mut metadata_scratch,
&mut w,
);
}
encode_frame_lossless_float(&image3s, alpha.as_ref(), config.num_threads, &mut w);
let codestream = w.into_bytes();
let alpha_bits_md = if has_alpha { 32 } else { 0 };
let gain_map = encode_gain_map(config)?;
finalize_container(
codestream,
config.exif.as_deref(),
config.xmp.as_deref(),
config.brotli_compression.as_deref(),
needs_level_10(32, true, alpha_bits_md),
gain_map.as_ref(),
)
}
fn encode_float_rgba(
input: &[f32],
width: usize,
height: usize,
has_alpha: bool,
config: &EncodeConfig,
bps: BitsPerSample,
) -> Result<Vec<u8>, EncodeError> {
let expected = checked_buffer_size::<f32>(width, height, if has_alpha { 4 } else { 3 })?;
if input.len() != expected {
return Err(EncodeError::InputSizeMismatch {
expected,
actual: input.len(),
});
}
if config.lossless && matches!(bps, BitsPerSample::F32) {
return encode_f32_lossless_rgba(input, width, height, has_alpha, config);
}
let distance = config.distance.max(MIN_DISTANCE);
let ctx = lossy_context(config, distance, XybMatrix::SPEC, width * height);
let mut scratch = Box::<CoderScratch>::default();
let transform = ColorTransform::for_float(
config.color_encoding.transfer,
config.color_encoding.primaries,
);
if has_alpha {
let linear = linearize_rgb::<_, _, 4>(input, width, height, &ctx, &mut scratch, &transform);
let mut ctx = ctx;
apply_yellow_opsin(&mut ctx, &linear, distance);
let alpha_plane = input
.as_chunks::<4>()
.0
.iter()
.map(|px| (px[3].clamp(0.0, 1.0) * 65535.0 + 0.5) as u16)
.collect();
let cfg = EncodeConfigImpl::with_distance(distance)
.with_progressive_from(config)
.with_alpha(AlphaPlane::from_u16_16bit(alpha_plane))
.with_bits_per_sample(bps)
.with_icc_profile(config.icc_profile.clone())
.with_exif(config.exif.clone())
.with_gain_map(encode_gain_map(config)?)
.with_xmp(config.xmp.clone())
.with_brotli_compression(config.brotli_compression.clone())
.with_orientation(config.orientation)
.with_color_encoding(config.color_encoding)
.with_intensity_target(config.intensity_target)
.with_num_threads(config.num_threads);
encode_with_context(&linear, &cfg, &ctx, &mut scratch)
} else {
let linear = linearize_rgb::<_, _, 3>(input, width, height, &ctx, &mut scratch, &transform);
let mut ctx = ctx;
apply_yellow_opsin(&mut ctx, &linear, distance);
let cfg = EncodeConfigImpl::with_distance(distance)
.with_progressive_from(config)
.with_bits_per_sample(bps)
.with_icc_profile(config.icc_profile.clone())
.with_exif(config.exif.clone())
.with_gain_map(encode_gain_map(config)?)
.with_xmp(config.xmp.clone())
.with_brotli_compression(config.brotli_compression.clone())
.with_orientation(config.orientation)
.with_color_encoding(config.color_encoding)
.with_intensity_target(config.intensity_target)
.with_num_threads(config.num_threads);
encode_with_context(&linear, &cfg, &ctx, &mut scratch)
}
}
fn encode_float_gray(
luma: &[f32],
width: usize,
height: usize,
config: &EncodeConfig,
bps: BitsPerSample,
) -> Result<Vec<u8>, EncodeError> {
let expected = checked_buffer_size::<f32>(width, height, 1)?;
if luma.len() != expected {
return Err(EncodeError::InputSizeMismatch {
expected: width * height,
actual: luma.len(),
});
}
let distance = config.distance.max(MIN_DISTANCE);
let ctx = lossy_context(config, distance, XybMatrix::SPEC, width * height);
let mut scratch = Box::<CoderScratch>::default();
let decoder = FloatTransferDecoder::new(config.color_encoding.transfer);
let linear = linearize_gray(luma, width, height, &ctx, &mut scratch, &decoder);
let cfg = EncodeConfigImpl::with_distance(distance)
.with_progressive_from(config)
.with_grayscale(true)
.with_bits_per_sample(bps)
.with_icc_profile(config.icc_profile.clone())
.with_exif(config.exif.clone())
.with_gain_map(encode_gain_map(config)?)
.with_xmp(config.xmp.clone())
.with_brotli_compression(config.brotli_compression.clone())
.with_orientation(config.orientation)
.with_color_encoding(config.color_encoding)
.with_intensity_target(config.intensity_target)
.with_num_threads(config.num_threads);
encode_with_context(&linear, &cfg, &ctx, &mut scratch)
}
pub fn encode_image_f32(
input: &[f32],
width: usize,
height: usize,
config: &EncodeConfig,
) -> Result<Vec<u8>, EncodeError> {
encode_float_rgba(input, width, height, false, config, BitsPerSample::F32)
}
pub fn encode_image_f16(
input: &[f32],
width: usize,
height: usize,
config: &EncodeConfig,
) -> Result<Vec<u8>, EncodeError> {
encode_float_rgba(input, width, height, false, config, BitsPerSample::F16)
}
pub fn encode_image_with_alpha_f32(
input: &[f32],
width: usize,
height: usize,
config: &EncodeConfig,
) -> Result<Vec<u8>, EncodeError> {
encode_float_rgba(input, width, height, true, config, BitsPerSample::F32)
}
pub fn encode_image_with_alpha_f16(
input: &[f32],
width: usize,
height: usize,
config: &EncodeConfig,
) -> Result<Vec<u8>, EncodeError> {
encode_float_rgba(input, width, height, true, config, BitsPerSample::F16)
}
pub fn encode_image_gray_f32(
input: &[f32],
width: usize,
height: usize,
config: &EncodeConfig,
) -> Result<Vec<u8>, EncodeError> {
encode_float_gray(input, width, height, config, BitsPerSample::F32)
}
pub fn encode_image_gray_f16(
input: &[f32],
width: usize,
height: usize,
config: &EncodeConfig,
) -> Result<Vec<u8>, EncodeError> {
encode_float_gray(input, width, height, config, BitsPerSample::F16)
}
fn progressive_schedule(
progressive: bool,
passes: Option<u32>,
shifts: Option<&[u32]>,
) -> Vec<u32> {
if let Some(s) = shifts {
let valid = !s.is_empty()
&& s.len() <= 11
&& *s.last().unwrap() == 0
&& s.iter().all(|&v| v <= 3)
&& s.array_windows::<2>().all(|w| w[0] >= w[1]);
if valid {
return s.to_vec();
}
}
let n = passes
.map(|p| p.clamp(1, 4))
.unwrap_or(if progressive { 2 } else { 1 }) as usize;
(0..n).rev().map(|p| p as u32).collect()
}
fn encode_with_context(
input: &Image3F,
config: &EncodeConfigImpl,
ctx: &EncodingContext,
scratch: &mut CoderScratch,
) -> Result<Vec<u8>, EncodeError> {
if input.xsize() == 0 || input.ysize() == 0 {
return Err(EncodeError::EmptyImage);
}
if input.xsize() > MAX_DIMENSION || input.ysize() > MAX_DIMENSION {
return Err(EncodeError::DimensionTooLarge {
width: input.xsize(),
height: input.ysize(),
});
}
if !config.distance.is_finite() || config.distance <= 0.0 {
return Err(EncodeError::InvalidDistance(config.distance));
}
if let Some(alpha) = config.alpha.as_ref() {
let expected = match &alpha {
AlphaPlane::U8(_) => checked_buffer_size::<u8>(input.xsize(), input.ysize(), 1)?,
AlphaPlane::U16 { .. } => checked_buffer_size::<u16>(input.xsize(), input.ysize(), 1)?,
AlphaPlane::F32(_) => checked_buffer_size::<f32>(input.xsize(), input.ysize(), 1)?,
};
if alpha.len() != expected {
return Err(EncodeError::AlphaSizeMismatch {
expected,
actual: alpha.len(),
});
}
}
let distance = config.distance.max(MIN_DISTANCE);
let mut w = BitWriter::new();
w.write(8, 0xFF);
w.write(8, CODESTREAM_MARKER as u64);
write_size_header(input.xsize(), input.ysize(), &mut w);
let coeff_shifts = progressive_schedule(
config.progressive,
config.progressive_passes,
config.progressive_shifts.as_deref(),
);
write_image_metadata(
config.tone_mapping(),
&config.color_encoding,
config.alpha.as_ref(),
config.icc_profile.as_deref(),
config.bits_per_sample,
config.lossless,
&ctx.xyb,
config.grayscale,
config.orientation,
scratch,
&mut w,
);
encode_frame(
ctx,
scratch,
distance,
input,
config.grayscale,
config.alpha.as_ref(),
&coeff_shifts,
config.patches,
&mut w,
)?;
let codestream = w.into_bytes();
let alpha_bits = config.alpha.as_ref().map(|a| a.bits() as u32).unwrap_or(0);
finalize_container(
codestream,
config.exif.as_deref(),
config.xmp.as_deref(),
config.brotli_compression.as_deref(),
needs_level_10(config.bits_per_sample.bits(), config.lossless, alpha_bits),
config.gain_map.as_ref(),
)
}
pub(crate) trait AsSignedInt {
fn to_signed_int(self, max_bp: u8) -> i32;
}
impl AsSignedInt for u8 {
#[inline]
fn to_signed_int(self, _: u8) -> i32 {
self as i32
}
}
impl AsSignedInt for u16 {
#[inline]
fn to_signed_int(self, max_bp: u8) -> i32 {
let max_colors = ((1u32 << max_bp) - 1) as i32;
(self as i32).min(max_colors)
}
}
fn encode_with_config_loseless<T: AsSignedInt + Copy>(
input: &[T],
width: usize,
height: usize,
has_alpha: bool,
max_bp: u8,
config: &EncodeConfigImpl,
) -> Result<Vec<u8>, EncodeError> {
if width == 0 || height == 0 {
return Err(EncodeError::EmptyImage);
}
let expected = checked_buffer_size::<T>(width, height, if has_alpha { 4 } else { 3 })?;
if input.len() != expected {
return Err(EncodeError::InputSizeMismatch {
expected,
actual: input.len(),
});
}
if width > MAX_DIMENSION || height > MAX_DIMENSION {
return Err(EncodeError::DimensionTooLarge { width, height });
}
if !config.distance.is_finite() || config.distance <= 0.0 {
return Err(EncodeError::InvalidDistance(config.distance));
}
let mut image3s = Image3Si::new(width, height);
let mut alpha_plane: Option<AlphaPlane> = None;
if has_alpha {
if max_bp > 8 {
let mut new_alpha_plane = vec![0u16; width * height];
for (y, (row, alpha_row)) in input
.chunks_exact(width * 4)
.zip(new_alpha_plane.chunks_exact_mut(width))
.enumerate()
{
let [r_row, g_row, b_row] = image3s.all_plane_rows_mut(y);
for ((((r, g), b), src), alpha) in r_row
.iter_mut()
.zip(g_row.iter_mut())
.zip(b_row.iter_mut())
.zip(row.as_chunks::<4>().0.iter())
.zip(alpha_row.iter_mut())
{
let ycocg = forward_ycocg(
src[0].to_signed_int(max_bp),
src[1].to_signed_int(max_bp),
src[2].to_signed_int(max_bp),
);
*r = ycocg.0;
*g = ycocg.1;
*b = ycocg.2;
*alpha = src[3].to_signed_int(max_bp) as u16;
}
}
alpha_plane = Some(AlphaPlane::U16 {
data: new_alpha_plane,
bits: max_bp,
});
} else {
let mut new_alpha_plane = vec![0u8; width * height];
for (y, (row, alpha_row)) in input
.chunks_exact(width * 4)
.zip(new_alpha_plane.chunks_exact_mut(width))
.enumerate()
{
let [r_row, g_row, b_row] = image3s.all_plane_rows_mut(y);
for ((((r, g), b), src), alpha) in r_row
.iter_mut()
.zip(g_row.iter_mut())
.zip(b_row.iter_mut())
.zip(row.as_chunks::<4>().0.iter())
.zip(alpha_row.iter_mut())
{
let ycocg = forward_ycocg(
src[0].to_signed_int(max_bp),
src[1].to_signed_int(max_bp),
src[2].to_signed_int(max_bp),
);
*r = ycocg.0;
*g = ycocg.1;
*b = ycocg.2;
*alpha = src[3].to_signed_int(max_bp) as u8;
}
}
alpha_plane = Some(AlphaPlane::U8(new_alpha_plane));
}
} else {
for (y, row) in input.chunks_exact(width * 3).enumerate() {
let [r_row, g_row, b_row] = image3s.all_plane_rows_mut(y);
for (((r, g), b), src) in r_row
.iter_mut()
.zip(g_row.iter_mut())
.zip(b_row.iter_mut())
.zip(row.as_chunks::<3>().0.iter())
{
let ycocg = forward_ycocg(
src[0].to_signed_int(max_bp),
src[1].to_signed_int(max_bp),
src[2].to_signed_int(max_bp),
);
*r = ycocg.0;
*g = ycocg.1;
*b = ycocg.2;
}
}
}
encode_lossless_planes(&image3s, &alpha_plane, max_bp, config)
}
fn encode_lossless_planes(
image3s: &Image3Si,
alpha_plane: &Option<AlphaPlane>,
max_bp: u8,
config: &EncodeConfigImpl,
) -> Result<Vec<u8>, EncodeError> {
let (width, height) = (image3s.xsize(), image3s.ysize());
let mut w = BitWriter::new();
w.write(8, 0xFF);
w.write(8, CODESTREAM_MARKER as u64);
write_size_header(width, height, &mut w);
{
let mut metadata_scratch = Box::new(CoderScratch::lossless());
write_image_metadata(
config.tone_mapping(),
&config.color_encoding,
alpha_plane.as_ref(),
config.icc_profile.as_deref(),
config.bits_per_sample,
config.lossless,
&XybMatrix::SPEC,
config.grayscale,
config.orientation,
&mut metadata_scratch,
&mut w,
);
}
let alpha_bits = alpha_plane.as_ref().map(|a| a.bits() as u32).unwrap_or(0);
let eff_bits = (max_bp as u32).max(alpha_bits);
let num_color = if config.grayscale { 1 } else { 3 };
encode_frame_lossless(
image3s,
alpha_plane.as_ref(),
eff_bits,
config.progressive,
config.patches,
num_color,
config.speed,
config.decoding_speed,
config.num_threads,
&mut w,
);
let codestream = w.into_bytes();
let alpha_bits = alpha_plane.as_ref().map(|a| a.bits() as u32).unwrap_or(0);
finalize_container(
codestream,
config.exif.as_deref(),
config.xmp.as_deref(),
config.brotli_compression.as_deref(),
needs_level_10(max_bp as u32, true, alpha_bits),
config.gain_map.as_ref(),
)
}
fn write_size(size: u32, w: &mut BitWriter) {
let size_minus_one = size - 1;
const BUCKET_BITS: [u32; 4] = [9, 13, 18, 30];
for (selector, &bits) in BUCKET_BITS.iter().enumerate() {
if size_minus_one < (1 << bits) {
w.write(2, selector as u64);
w.write(bits as usize, size_minus_one as u64);
return;
}
}
unreachable!("dimension was bounds-checked against MAX_DIMENSION");
}
fn write_size_header(xsize: usize, ysize: usize, w: &mut BitWriter) {
assert!(
xsize <= MAX_DIMENSION && ysize <= MAX_DIMENSION,
"image too large: max dimension is {MAX_DIMENSION}"
);
w.write(1, 0); write_size(ysize as u32, w);
w.write(3, 0); write_size(xsize as u32, w);
}
pub(crate) fn needs_level_10(bits: u32, lossless: bool, alpha_bits: u32) -> bool {
(lossless && bits >= 16) || alpha_bits >= 16
}
fn push_container_box(out: &mut Vec<u8>, kind: &[u8; 4], contents: &[u8]) {
let size = 8u64 + contents.len() as u64;
if size <= u32::MAX as u64 {
out.extend_from_slice(&(size as u32).to_be_bytes());
out.extend_from_slice(kind);
} else {
out.extend_from_slice(&1u32.to_be_bytes());
out.extend_from_slice(kind);
out.extend_from_slice(&(size + 8).to_be_bytes());
}
out.extend_from_slice(contents);
}
fn push_metadata_box(
out: &mut Vec<u8>,
kind: &[u8; 4],
contents: &[u8],
compressor: Option<&dyn BrotliCompression>,
) -> Result<(), EncodeError> {
if let Some(compressor) = compressor {
let compressed = compressor.compress(contents)?;
let mut brob = Vec::with_capacity(4 + compressed.len());
brob.extend_from_slice(kind);
brob.extend_from_slice(&compressed);
push_container_box(out, b"brob", &brob);
} else {
push_container_box(out, kind, contents);
}
Ok(())
}
pub(crate) fn wrap_jxl_container(
codestream: Vec<u8>,
level: u8,
exif: Option<&[u8]>,
xmp: Option<&[u8]>,
compressor: Option<&dyn BrotliCompression>,
gain_map: Option<&[u8]>,
) -> Result<Vec<u8>, EncodeError> {
let exif_extra = exif.map(|e| e.len() + 12).unwrap_or(0);
let xmp_extra = xmp.map(|x| x.len() + 8).unwrap_or(0);
let gain_map_extra = gain_map.map(|g| g.len() + 8).unwrap_or(0);
let mut out =
Vec::with_capacity(codestream.len() + 41 + exif_extra + xmp_extra + gain_map_extra);
out.extend_from_slice(&[
0, 0, 0, 0x0C, b'J', b'X', b'L', b' ', 0x0D, 0x0A, 0x87, 0x0A,
]);
out.extend_from_slice(&[
0, 0, 0, 0x14, b'f', b't', b'y', b'p', b'j', b'x', b'l', b' ', 0, 0, 0, 0, b'j', b'x',
b'l', b' ',
]);
out.extend_from_slice(&[0, 0, 0, 0x09, b'j', b'x', b'l', b'l', level]);
push_container_box(&mut out, b"jxlc", &codestream);
if let Some(g) = gain_map {
push_container_box(&mut out, b"jhgm", g);
}
if let Some(e) = exif {
let mut contents = Vec::with_capacity(4 + e.len());
contents.extend_from_slice(&0u32.to_be_bytes()); contents.extend_from_slice(e);
push_metadata_box(&mut out, b"Exif", &contents, compressor)?;
}
if let Some(x) = xmp {
push_metadata_box(&mut out, b"xml ", x, compressor)?;
}
Ok(out)
}
fn finalize_container(
codestream: Vec<u8>,
exif: Option<&[u8]>,
xmp: Option<&[u8]>,
compressor: Option<&dyn BrotliCompression>,
need_l10: bool,
gain_map: Option<&EncodedGainMap>,
) -> Result<Vec<u8>, EncodeError> {
let need_l10 = need_l10 || gain_map.is_some_and(|g| g.needs_level_10);
if need_l10 || exif.is_some() || xmp.is_some() || gain_map.is_some() {
wrap_jxl_container(
codestream,
if need_l10 { 10 } else { 5 },
exif,
xmp,
compressor,
gain_map.map(|g| g.bundle.as_slice()),
)
} else {
Ok(codestream)
}
}
fn write_int_bit_depth(bits: u32, w: &mut BitWriter) {
w.write(1, 0); match bits {
8 => w.write(2, 0),
10 => w.write(2, 1),
12 => w.write(2, 2),
_ => {
w.write(2, 3); w.write(6, (bits - 1) as u64);
}
}
}
fn write_float_bit_depth(bits: u32, exp_bits: u32, w: &mut BitWriter) {
w.write(1, 1); match bits {
32 => w.write(2, 0),
16 => w.write(2, 1),
24 => w.write(2, 2),
_ => {
w.write(2, 3);
w.write(6, (bits - 1) as u64);
}
}
w.write(4, (exp_bits - 1) as u64);
}
fn write_image_metadata(
tm: ToneMappingParams,
color_encoding: &ColorEncoding,
alpha: Option<&AlphaPlane>,
icc_profile: Option<&[u8]>,
bps: BitsPerSample,
lossless: bool,
xyb: &XybMatrix,
grayscale: bool,
orientation: Orientation,
scratch: &mut CoderScratch,
w: &mut BitWriter,
) {
w.write(1, 0); let extra_fields = !tm.is_default() || orientation != Orientation::Normal;
w.write(1, if extra_fields { 1 } else { 0 }); if extra_fields {
w.write(3, orientation.to_u3()); w.write(1, 0); w.write(1, 0); w.write(1, 0); }
if bps.is_float() {
write_float_bit_depth(bps.bits(), bps.exp_bits(), w);
} else {
write_int_bit_depth(bps.bits(), w);
}
let alpha_bits = alpha.map(|a| a.bits() as u32).unwrap_or(0);
let needs_32 = (lossless && bps.bits() >= 16) || alpha_bits >= 16;
w.write(1, if needs_32 { 0 } else { 1 });
if let Some(alpha) = alpha {
w.write(2, 1); match alpha.bits() {
8 => {
w.write(1, 1); }
bits => {
w.write(1, 0); w.write(2, 0); if alpha.is_float() {
write_float_bit_depth(32, 8, w); } else {
write_int_bit_depth(bits as u32, w);
}
w.write(2, 0); w.write(2, 0); w.write(1, 0); }
}
} else {
w.write(2, 0); }
w.write(1, if lossless { 0 } else { 1 }); let want_icc = icc_profile.is_some();
write_color_encoding_with_icc(color_encoding, want_icc, grayscale, w);
if extra_fields {
w.write(1, 0);
let it = tm.intensity_target.unwrap_or(255.0);
w.write(16, crate::util::f32_to_f16_bits(it) as u64); w.write(16, crate::util::f32_to_f16_bits(tm.min_nits) as u64); w.write(1, if tm.relative_to_max_display { 1 } else { 0 }); w.write(16, crate::util::f32_to_f16_bits(tm.linear_below) as u64); }
w.write(2, 0); if lossless || xyb.is_decoder_default() {
w.write(1, 1); } else {
w.write(1, 0); w.write(1, 0); for &v in &xyb.inv {
w.write(16, crate::util::f32_to_f16_bits(v) as u64);
}
for _ in 0..3 {
w.write(16, crate::util::f32_to_f16_bits(-0.003_793_073_4) as u64);
}
for v in [1.0 - 0.054_650_075, 1.0 - 0.070_054_5, 1.0, 0.145] {
w.write(16, crate::util::f32_to_f16_bits(v) as u64);
}
w.write(3, 0); }
if let Some(icc) = icc_profile {
crate::icc_codec::write_icc_stream(icc, &mut scratch.huffman_pool, w);
}
w.zero_pad_to_byte();
}
#[cfg(test)]
mod tests {
use super::*;
fn close(a: f32, b: f32) -> bool {
(a - b).abs() < 1e-4
}
#[test]
fn quality_mapping_anchor_points() {
assert!(close(distance_from_quality(100.0), 0.05));
assert!(close(distance_from_quality(99.0), 0.1));
assert!(close(distance_from_quality(90.0), 1.0));
assert!(close(distance_from_quality(30.0), 6.4));
let d25 = distance_from_quality(25.0);
assert!(d25 > 6.4 && d25 < 7.0, "q=25 -> {d25}");
assert!(close(distance_from_quality(0.0), 25.0));
assert!(close(distance_from_quality(-50.0), 25.0));
assert!(close(distance_from_quality(110.0), 0.05));
}
#[test]
fn quality_mapping_monotone() {
let mut prev = distance_from_quality(0.0);
for q in 1..=100 {
let d = distance_from_quality(q as f32);
assert!(d <= prev, "non-monotonic at q={q}: prev={prev}, d={d}");
prev = d;
}
}
#[test]
fn default_speed_is_fast() {
assert_eq!(Speed::default(), Speed::Fast);
assert_eq!(EncodeConfig::default().speed, Speed::Fast);
}
#[test]
fn srgb_linearization_uses_requested_threads() {
use std::collections::HashSet;
use std::sync::{Barrier, Mutex};
let config = EncodeConfig::default().with_num_threads(4);
let ctx = lossy_context(&config, 1.0, XybMatrix::SPEC, 1);
let mut scratch = Box::<CoderScratch>::default();
let mut image = Image3F::new(8, 4);
let barrier = Barrier::new(4);
let threads = Mutex::new(HashSet::new());
for_each_linear_band(&mut image, &ctx, &mut scratch, |_start, _band| {
threads.lock().unwrap().insert(std::thread::current().id());
barrier.wait();
});
assert_eq!(threads.into_inner().unwrap().len(), 4);
}
#[test]
#[should_panic(expected = "quality must not be NaN")]
fn quality_nan_panics() {
let _ = distance_from_quality(f32::NAN);
}
}
#[cfg(test)]
mod encode_smoke_tests {
use super::*;
const W: usize = 16;
const H: usize = 16;
fn rgb8() -> Vec<u8> {
(0..W * H * 3).map(|i| (i % 256) as u8).collect()
}
fn box_payload<'a>(container: &'a [u8], wanted: &[u8; 4]) -> Option<&'a [u8]> {
let mut pos = 0usize;
while pos + 8 <= container.len() {
let small = u32::from_be_bytes(container[pos..pos + 4].try_into().unwrap()) as usize;
let kind: &[u8; 4] = container[pos + 4..pos + 8].try_into().unwrap();
let (header, size) = if small == 1 {
if pos + 16 > container.len() {
return None;
}
(
16,
u64::from_be_bytes(container[pos + 8..pos + 16].try_into().unwrap()) as usize,
)
} else {
(8, small)
};
if size < header || pos.checked_add(size)? > container.len() {
return None;
}
if kind == wanted {
return Some(&container[pos + header..pos + size]);
}
pos += size;
}
None
}
fn box_kinds(container: &[u8]) -> Vec<[u8; 4]> {
let mut kinds = Vec::new();
let mut pos = 0usize;
while pos + 8 <= container.len() {
let size = u32::from_be_bytes(container[pos..pos + 4].try_into().unwrap()) as usize;
kinds.push(container[pos + 4..pos + 8].try_into().unwrap());
assert!(size >= 8, "large boxes not expected in these tests");
pos += size;
}
assert_eq!(pos, container.len());
kinds
}
fn gain_map_metadata() -> crate::IsoGainMap {
crate::IsoGainMap::from_floats(&crate::GainMapFloats {
max: [2.0; 3],
alternate_hdr_headroom: 2.0,
..crate::GainMapFloats::default()
})
.unwrap()
}
fn gray_gain_map(w: usize, h: usize) -> crate::GainMap {
let gain: Vec<u8> = (0..w * h).map(|i| (i * 4) as u8).collect();
crate::GainMap::gray8(gain, w, h, gain_map_metadata())
}
#[test]
fn gain_map_is_written_to_a_jhgm_box_after_the_codestream() {
let md = gain_map_metadata();
let gm = gray_gain_map(8, 8)
.with_lossless(true)
.with_alternate_color_encoding(ColorEncoding::bt2020_pq());
let encoded = encode_image(&rgb8(), W, H, &lossy().with_gain_map(gm)).unwrap();
assert_eq!(
box_kinds(&encoded),
[*b"JXL ", *b"ftyp", *b"jxll", *b"jxlc", *b"jhgm"]
);
assert_eq!(box_payload(&encoded, b"jxll"), Some(&[5u8][..]));
let jhgm = box_payload(&encoded, b"jhgm").expect("jhgm box");
let p = crate::gain_map::parse_jhgm_bundle(jhgm).unwrap();
assert_eq!(p.version, 0);
assert_eq!(crate::IsoGainMap::from_metadata(p.metadata).unwrap(), md);
assert!(!p.color_encoding.is_empty());
assert!(p.alt_icc.is_empty());
assert_eq!(&p.codestream[..2], &[0xFF, 0x0A]);
assert_ne!(&p.codestream[..4], &[0, 0, 0, 0x0C]);
}
#[test]
fn gain_map_box_precedes_metadata_boxes() {
let exif = vec![b'I', b'I', 42, 0, 8, 0, 0, 0];
let encoded = encode_image(
&rgb8(),
W,
H,
&lossy()
.with_exif(exif.clone())
.with_xmp(b"<x/>".to_vec())
.with_gain_map(gray_gain_map(4, 4)),
)
.unwrap();
assert_eq!(
box_kinds(&encoded),
[
*b"JXL ", *b"ftyp", *b"jxll", *b"jxlc", *b"jhgm", *b"Exif", *b"xml "
]
);
assert_eq!(box_payload(&encoded, b"xml "), Some(&b"<x/>"[..]));
}
#[test]
fn level_10_gain_map_raises_the_file_level() {
let gain: Vec<u16> = (0..4 * 4).map(|i| (i * 4000) as u16).collect();
let gm = crate::GainMap::gray16(gain, 16, 4, 4, gain_map_metadata()).with_lossless(true);
let encoded = encode_image(&rgb8(), W, H, &lossy().with_gain_map(gm)).unwrap();
assert_eq!(box_payload(&encoded, b"jxll"), Some(&[10u8][..]));
let jhgm = box_payload(&encoded, b"jhgm").unwrap();
let p = crate::gain_map::parse_jhgm_bundle(jhgm).unwrap();
assert_eq!(&p.codestream[..2], &[0xFF, 0x0A]);
}
#[test]
fn gain_map_rides_along_every_primary_encoder_path() {
let cfg = lossy().with_gain_map(
crate::GainMap::rgb8(
(0..4 * 4 * 3).map(|i| i as u8).collect(),
4,
4,
gain_map_metadata(),
)
.with_distance(3.0),
);
let rgba: Vec<u8> = (0..W * H * 4).map(|i| i as u8).collect();
let gray: Vec<u8> = (0..W * H).map(|i| i as u8).collect();
let rgb16: Vec<u16> = (0..W * H * 3).map(|i| (i * 7) as u16).collect();
let f32s: Vec<f32> = (0..W * H * 3).map(|i| (i % 255) as f32 / 255.0).collect();
let outputs = [
encode_image_with_alpha(&rgba, W, H, &cfg).unwrap(),
encode_image_gray(&gray, W, H, &cfg).unwrap(),
encode_image_16bit(&rgb16, W, H, &cfg).unwrap(),
encode_image_f32(&f32s, W, H, &cfg).unwrap(),
encode_image(
&rgb8(),
W,
H,
&lossless().with_gain_map(gray_gain_map(4, 4)),
)
.unwrap(),
encode_image_16bit(&rgb16, W, H, &lossless().with_gain_map(gray_gain_map(4, 4)))
.unwrap(),
encode_image_f32(&f32s, W, H, &lossless().with_gain_map(gray_gain_map(4, 4))).unwrap(),
];
for out in &outputs {
let jhgm = box_payload(out, b"jhgm").expect("every path writes the jhgm box");
let p = crate::gain_map::parse_jhgm_bundle(jhgm).unwrap();
assert_eq!(&p.codestream[..2], &[0xFF, 0x0A]);
}
}
#[test]
fn invalid_gain_map_fails_the_encode() {
let gm = crate::GainMap::gray8(vec![0; 15], 4, 4, gain_map_metadata());
assert!(matches!(
encode_image(&rgb8(), W, H, &lossy().with_gain_map(gm)),
Err(EncodeError::GainMapSizeMismatch {
expected: 16,
actual: 15
})
));
}
#[test]
fn xmp_is_written_to_an_xml_box() {
let xmp = b"<x:xmpmeta xmlns:x=\"adobe:ns:meta/\"/>";
let encoded = encode_image(&rgb8(), W, H, &lossy().with_xmp(xmp.to_vec())).unwrap();
assert_eq!(box_payload(&encoded, b"xml "), Some(xmp.as_slice()));
}
#[test]
fn custom_brotli_writes_brob_metadata() {
struct MarkerCompressor;
impl BrotliCompression for MarkerCompressor {
fn compress(&self, data: &[u8]) -> Result<Vec<u8>, EncodeError> {
assert_eq!(data, b"<x:xmpmeta/>");
Ok(vec![0xAA, 0xBB])
}
}
let encoded = encode_image(
&rgb8(),
W,
H,
&lossy()
.with_xmp(b"<x:xmpmeta/>".to_vec())
.with_brotli_compression(Box::new(MarkerCompressor)),
)
.unwrap();
assert_eq!(box_payload(&encoded, b"brob"), Some(&b"xml \xAA\xBB"[..]));
assert!(box_payload(&encoded, b"xml ").is_none());
}
#[test]
fn custom_brotli_error_is_returned() {
struct FailingCompressor;
impl BrotliCompression for FailingCompressor {
fn compress(&self, _data: &[u8]) -> Result<Vec<u8>, EncodeError> {
Err(EncodeError::Brotli("backend failed".into()))
}
}
assert_eq!(
encode_image(
&rgb8(),
W,
H,
&lossy()
.with_xmp(b"<x:xmpmeta/>".to_vec())
.with_brotli_compression(Box::new(FailingCompressor)),
),
Err(EncodeError::Brotli("backend failed".into()))
);
}
fn rgba8() -> Vec<u8> {
(0..W * H * 4).map(|i| (i % 256) as u8).collect()
}
fn rgb16() -> Vec<u16> {
(0..W * H * 3).map(|i| (i % 65536) as u16).collect()
}
fn rgba16() -> Vec<u16> {
(0..W * H * 4).map(|i| (i % 65536) as u16).collect()
}
fn gray8() -> Vec<u8> {
(0..W * H).map(|i| (i % 256) as u8).collect()
}
fn gray_alpha8() -> Vec<u8> {
(0..W * H * 2).map(|i| (i % 256) as u8).collect()
}
fn gray16() -> Vec<u16> {
(0..W * H).map(|i| (i % 65536) as u16).collect()
}
fn gray_alpha16() -> Vec<u16> {
(0..W * H * 2).map(|i| (i % 65536) as u16).collect()
}
fn rgb10() -> Vec<u16> {
(0..W * H * 3).map(|i| (i % 1024) as u16).collect()
}
fn rgba10() -> Vec<u16> {
(0..W * H * 4).map(|i| (i % 1024) as u16).collect()
}
fn rgb12() -> Vec<u16> {
(0..W * H * 3).map(|i| (i % 4096) as u16).collect()
}
fn rgba12() -> Vec<u16> {
(0..W * H * 4).map(|i| (i % 4096) as u16).collect()
}
fn gray10() -> Vec<u16> {
(0..W * H).map(|i| (i % 1024) as u16).collect()
}
fn gray_alpha10() -> Vec<u16> {
(0..W * H * 2).map(|i| (i % 1024) as u16).collect()
}
fn gray12() -> Vec<u16> {
(0..W * H).map(|i| (i % 4096) as u16).collect()
}
fn gray_alpha12() -> Vec<u16> {
(0..W * H * 2).map(|i| (i % 4096) as u16).collect()
}
fn rgb_f32() -> Vec<f32> {
(0..W * H * 3).map(|i| (i % 256) as f32 / 255.0).collect()
}
fn rgba_f32() -> Vec<f32> {
(0..W * H * 4).map(|i| (i % 256) as f32 / 255.0).collect()
}
fn gray_f32() -> Vec<f32> {
(0..W * H).map(|i| (i % 256) as f32 / 255.0).collect()
}
fn lossy() -> EncodeConfig {
EncodeConfig::default().with_distance(1.0)
}
fn lossless() -> EncodeConfig {
EncodeConfig::default().with_lossless(true)
}
fn ok(r: Result<Vec<u8>, EncodeError>) {
let bytes = r.expect("encode failed");
assert!(!bytes.is_empty(), "encoded output is empty");
}
#[test]
fn rgb8_lossy() {
ok(encode_image(&rgb8(), W, H, &lossy()));
}
#[cfg(feature = "splines")]
fn line_art(size: usize) -> Vec<u8> {
let mut px = vec![0u8; size * size * 3];
for y in 0..size {
for x in 0..size {
let mut v = 150.0 + 60.0 * (x + y) as f32 / (2 * size) as f32;
for k in 0..6 {
let phase = k as f32 * 0.9;
let cy = size as f32 * (0.15 + 0.13 * k as f32)
+ 18.0 * (x as f32 * 0.035 + phase).sin();
let d = (y as f32 - cy).abs();
v -= 120.0 * (-0.5 * (d / 0.8).powi(2)).exp();
}
let i = (y * size + x) * 3;
px[i] = v.clamp(0.0, 255.0) as u8;
px[i + 1] = (v * 0.92).clamp(0.0, 255.0) as u8;
px[i + 2] = (v * 0.85).clamp(0.0, 255.0) as u8;
}
}
px
}
#[cfg(feature = "splines")]
fn slow_lossy(distance: f32) -> EncodeConfig {
EncodeConfig::default()
.with_distance(distance)
.with_speed(Speed::Slow)
}
#[test]
#[cfg(feature = "splines")]
fn splines_reduce_thin_line_art() {
const S: usize = 256;
let pixels = line_art(S);
let plain = encode_image(&pixels, S, S, &slow_lossy(3.0)).unwrap();
let with = encode_image(&pixels, S, S, &slow_lossy(3.0).with_splines(true)).unwrap();
assert!(
with.len() * 100 < plain.len() * 90,
"splines should win clearly on thin line art: {} vs {}",
with.len(),
plain.len()
);
}
#[test]
#[cfg(feature = "splines")]
fn splines_join_crossed_grid_lines() {
const S: usize = 256;
let mut pixels = Vec::with_capacity(S * S * 3);
for y in 0..S {
for x in 0..S {
let mut v = 170.0 + 70.0 * (x + y) as f32 / (2 * S) as f32;
if (12..S - 12).contains(&x) && (12..S - 12).contains(&y) {
for axis in [x, y] {
let d = ((axis - 12 + 18) % 36) as f32 - 18.0;
v -= 65.0 * (-0.5 * (d / 0.65).powi(2)).exp();
}
}
pixels.extend([v as u8, (v * 0.95) as u8, (v * 0.9) as u8]);
}
}
let config = slow_lossy(2.0).with_patches(false).with_num_threads(1);
let plain = encode_image(&pixels, S, S, &config).unwrap();
let config = config.with_splines(true);
let joined = encode_image(&pixels, S, S, &config).unwrap();
assert!(
joined.len() * 100 < plain.len() * 80,
"whole grid lines should save more than isolated fragments: {} vs {}",
joined.len(),
plain.len()
);
assert_eq!(
joined,
encode_image(&pixels, S, S, &config.with_num_threads(4)).unwrap()
);
}
#[test]
#[cfg(feature = "splines")]
fn splines_are_inert_without_lines() {
const S: usize = 128;
let mut pixels = vec![0u8; S * S * 3];
for y in 0..S {
for x in 0..S {
let i = (y * S + x) * 3;
pixels[i] = (x * 2) as u8;
pixels[i + 1] = (y * 2) as u8;
pixels[i + 2] = (x + y) as u8;
}
}
let plain = encode_image(&pixels, S, S, &slow_lossy(2.0)).unwrap();
let with = encode_image(&pixels, S, S, &slow_lossy(2.0).with_splines(true)).unwrap();
assert_eq!(plain, with);
}
#[test]
#[cfg(feature = "splines")]
fn splines_only_run_at_slow_speed_and_default_decoding_speed() {
const S: usize = 256;
let pixels = line_art(S);
let fast = EncodeConfig::default()
.with_distance(3.0)
.with_speed(Speed::Fast);
assert_eq!(
encode_image(&pixels, S, S, &fast).unwrap(),
encode_image(&pixels, S, S, &fast.clone().with_splines(true)).unwrap()
);
let quick_decode = slow_lossy(3.0).with_decoding_speed(DecodingSpeed::Fast);
assert_eq!(
encode_image(&pixels, S, S, &quick_decode).unwrap(),
encode_image(&pixels, S, S, &quick_decode.clone().with_splines(true)).unwrap()
);
}
#[test]
#[cfg(feature = "splines")]
fn splines_coexist_with_patches() {
const S: usize = 256;
let pixels = line_art(S);
let both = slow_lossy(3.0).with_splines(true).with_patches(true);
let plain = encode_image(&pixels, S, S, &slow_lossy(3.0).with_patches(true)).unwrap();
let with = encode_image(&pixels, S, S, &both).unwrap();
assert!(with.len() < plain.len());
}
#[test]
#[cfg(feature = "splines")]
fn splines_cross_repeated_tiles() {
const S: usize = 256;
const PERIOD: f32 = 12.3;
let rule = |t: usize| {
let d = ((t as f32 + PERIOD / 2.0) % PERIOD - PERIOD / 2.0).abs();
(1.0 - d).max(0.0)
};
let mut pixels = vec![0u8; S * S * 3];
let mut state = 0x1234_5678u32;
for y in 0..S {
for x in 0..S {
let mut v = 236.0 - 46.0 * rule(x).max(rule(y));
let cy = 48.0 + 30.0 * (x as f32 * 0.021).sin();
v -= 170.0 * (-0.5 * ((y as f32 - cy) / 0.9).powi(2)).exp();
if y >= 96 {
state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
v = (state >> 24) as f32;
}
let i = (y * S + x) * 3;
pixels[i] = (v * 0.35).clamp(0.0, 255.0) as u8;
pixels[i + 1] = (v * 0.45).clamp(0.0, 255.0) as u8;
pixels[i + 2] = v.clamp(0.0, 255.0) as u8;
}
}
let patched = encode_image(&pixels, S, S, &slow_lossy(2.0).with_patches(true)).unwrap();
let both = slow_lossy(2.0).with_splines(true).with_patches(true);
let with = encode_image(&pixels, S, S, &both).unwrap();
assert!(
with.len() < patched.len(),
"splines must survive next to tile patches: {} >= {}",
with.len(),
patched.len()
);
}
#[test]
fn lossy_patches_are_rate_safe() {
let plain = encode_image(&rgb8(), W, H, &lossy()).unwrap();
let checked = encode_image(&rgb8(), W, H, &lossy().with_patches(true)).unwrap();
assert!(checked.len() <= plain.len());
}
#[test]
fn lossy_patches_reduce_repeated_regions() {
const PW: usize = 256;
const PH: usize = 256;
let mut state = 0x89ab_cdefu32;
let mut pixels = vec![0u8; PW * PH * 3];
for sample in &mut pixels {
state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
*sample = (state >> 24) as u8;
}
let tile: Vec<u8> = (0..16)
.flat_map(|y| pixels[(y * PW * 3)..(y * PW * 3 + 48)].iter().copied())
.collect();
for ty in 0..16 {
for tx in 0..16 {
if (tx + ty) % 2 != 0 {
continue;
}
for y in 0..16 {
let dst = ((ty * 16 + y) * PW + tx * 16) * 3;
pixels[dst..dst + 48].copy_from_slice(&tile[y * 48..(y + 1) * 48]);
}
}
}
let plain = encode_image(&pixels, PW, PH, &lossy().with_patches(false)).unwrap();
let patched = encode_image(&pixels, PW, PH, &lossy().with_patches(true)).unwrap();
assert!(
patched.len() < plain.len(),
"lossy patches should win on repeated complex regions: {} >= {}",
patched.len(),
plain.len()
);
}
#[test]
fn rgb8_slow_low_quality_lossy() {
const SIDE: usize = 64;
let pixels: Vec<u8> = (0..SIDE * SIDE * 3).map(|i| (i % 251) as u8).collect();
ok(encode_image(
&pixels,
SIDE,
SIDE,
&EncodeConfig::default()
.with_distance(3.0)
.with_speed(Speed::Slow),
));
}
#[test]
fn rgb8_slow_low_quality_rect_merge_lossy() {
let config = EncodeConfig::default()
.with_distance(2.5)
.with_speed(Speed::Slow);
for (width, height) in [(32, 64), (64, 32)] {
let pixels = vec![128u8; width * height * 3];
ok(encode_image(&pixels, width, height, &config));
}
}
#[test]
fn lossy_output_is_independent_of_thread_count() {
const WIDTH: usize = 257;
const HEIGHT: usize = 65;
let input: Vec<u8> = (0..WIDTH * HEIGHT * 3)
.map(|i| i.wrapping_mul(37).wrapping_add((i / 7).wrapping_mul(13)) as u8)
.collect();
let config = lossy().with_speed(Speed::Slow);
let single = encode_image(&input, WIDTH, HEIGHT, &config.clone().with_num_threads(1))
.expect("single-threaded lossy encode failed");
let threaded = encode_image(&input, WIDTH, HEIGHT, &config.with_num_threads(4))
.expect("multi-threaded lossy encode failed");
assert_eq!(single, threaded);
}
#[test]
fn rgba_lossy_patches_reduce_repeated_regions() {
const PW: usize = 256;
const PH: usize = 256;
let mut pixels = vec![0u8; PW * PH * 4];
for (i, px) in pixels.as_chunks_mut::<4>().0.iter_mut().enumerate() {
let (x, y) = (i % PW, i / PW);
let (tx, ty) = (x % 16, y % 16);
if (x / 16 + y / 16) % 4 != 0 {
px[0] = ((tx / 4) * 40 + (ty / 4) * 17) as u8;
px[1] = ((tx / 4) * 25 + (ty / 4) * 31) as u8;
px[2] = ((tx / 4) * 11 + (ty / 4) * 45) as u8;
} else {
let s = (i as u32)
.wrapping_mul(1_664_525)
.wrapping_add(1_013_904_223);
px[0] = (s >> 24) as u8;
px[1] = (s >> 16) as u8;
px[2] = (s >> 8) as u8;
}
px[3] = 255;
}
let cfg = |patches: bool| {
EncodeConfig::default()
.with_lossless(false)
.with_distance(1.0)
.with_patches(patches)
};
let plain = encode_image_with_alpha(&pixels, PW, PH, &cfg(false)).unwrap();
let patched = encode_image_with_alpha(&pixels, PW, PH, &cfg(true)).unwrap();
assert!(
patched.len() < plain.len(),
"alpha image patches should win: {} >= {}",
patched.len(),
plain.len()
);
}
#[test]
fn rgb8_lossless() {
ok(encode_image(&rgb8(), W, H, &lossless()));
}
#[test]
fn rgb8_lossless_patches_reduce_repeated_tiles() {
const PW: usize = 96;
const PH: usize = 64;
let mut pixels = vec![0u8; PW * PH * 3];
for y in 0..PH {
for x in 0..PW {
let tx = x % 16;
let ty = y % 16;
let p = (y * PW + x) * 3;
pixels[p] = (tx * 13 + ty * 3) as u8;
pixels[p + 1] = (tx * 5 + ty * 11) as u8;
pixels[p + 2] = (tx * 7 + ty * 9) as u8;
}
}
let plain = encode_image(&pixels, PW, PH, &lossless().with_patches(false)).unwrap();
let patched = encode_image(&pixels, PW, PH, &lossless().with_patches(true)).unwrap();
assert!(
patched.len() < plain.len(),
"patch dictionary should reduce a repeated-tile image: {} >= {}",
patched.len(),
plain.len()
);
}
#[test]
fn rgb8_lossless_patches_fall_back_when_rate_is_worse() {
const PW: usize = 64;
const PH: usize = 64;
let mut state = 0x1234_5678u32;
let mut pixels = vec![0u8; PW * PH * 3];
for sample in &mut pixels {
state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
*sample = (state >> 24) as u8;
}
for y in 0..16 {
for x in 0..48 {
let pixel = (y * PW + x) * 3;
for sample in &mut pixels[pixel..pixel + 3] {
*sample = 0;
}
}
}
let plain = encode_image(&pixels, PW, PH, &lossless()).unwrap();
let checked = encode_image(&pixels, PW, PH, &lossless().with_patches(true)).unwrap();
assert_eq!(checked, plain, "a losing patch candidate must be discarded");
}
#[test]
fn rgb8_lossless_slow_adaptive() {
ok(encode_image(
&rgb8(),
W,
H,
&lossless().with_speed(Speed::Slow),
));
}
#[test]
fn fastest_speed_encodes_dct8_only() {
const WIDTH: usize = 128;
const HEIGHT: usize = 128;
let input: Vec<u8> = (0..WIDTH * HEIGHT * 3)
.map(|i| (((i / 3) % WIDTH) / 2 + ((i / 3) / WIDTH) / 2) as u8)
.collect();
let config = lossy().with_distance(2.0);
let fastest = encode_image(
&input,
WIDTH,
HEIGHT,
&config.clone().with_speed(Speed::Fastest),
)
.expect("Fastest encode failed");
let fast = encode_image(
&input,
WIDTH,
HEIGHT,
&config.clone().with_speed(Speed::Fast),
)
.expect("Fast encode failed");
assert!(!fastest.is_empty());
assert_ne!(
fastest, fast,
"Fastest should skip the transform search Fast performs"
);
}
#[test]
fn lossless_output_is_independent_of_thread_count() {
const WIDTH: usize = 257;
const HEIGHT: usize = 257;
let input: Vec<u8> = (0..WIDTH * HEIGHT * 3)
.map(|i| i.wrapping_mul(37).wrapping_add((i / 7).wrapping_mul(13)) as u8)
.collect();
for speed in [Speed::Fastest, Speed::Fast, Speed::Slow] {
let single = encode_image(
&input,
WIDTH,
HEIGHT,
&lossless().with_speed(speed).with_num_threads(1),
)
.expect("single-threaded lossless encode failed");
let threaded = encode_image(
&input,
WIDTH,
HEIGHT,
&lossless().with_speed(speed).with_num_threads(8),
)
.expect("multi-threaded lossless encode failed");
assert_eq!(single, threaded, "output changed for {speed:?}");
}
}
#[test]
fn decoding_speed_tiers_encode_and_restrict_tools() {
const WIDTH: usize = 96;
const HEIGHT: usize = 96;
let input: Vec<u8> = (0..WIDTH * HEIGHT * 3)
.map(|i| {
let (px, c) = (i / 3, i % 3);
let (x, y) = (px % WIDTH, px / WIDTH);
let (x, y, c) = (x as i64, y as i64, c as i64);
let base = (x * x) / 40 + (y * y) / 50 + (x * y) / 60 + 31 * c;
(base as u8).wrapping_add(((x * y) % 5) as u8)
})
.collect();
for speed in [Speed::Fast, Speed::Slow] {
let encode = |ds: DecodingSpeed| {
encode_image(
&input,
WIDTH,
HEIGHT,
&lossless()
.with_speed(speed)
.with_decoding_speed(ds)
.with_num_threads(1),
)
.expect("lossless encode failed")
};
let slow_tier = encode(DecodingSpeed::Slow);
let fast_tier = encode(DecodingSpeed::Fast);
let fastest_tier = encode(DecodingSpeed::Fastest);
let unset = encode_image(
&input,
WIDTH,
HEIGHT,
&lossless().with_speed(speed).with_num_threads(1),
)
.expect("lossless encode failed");
assert_eq!(slow_tier, unset, "{speed:?}: Slow must equal unset");
assert_ne!(slow_tier, fast_tier, "{speed:?}: Fast tier inert");
assert_ne!(slow_tier, fastest_tier, "{speed:?}: Fastest tier inert");
}
}
#[test]
fn local_palette_rgb_and_rgba_are_thread_deterministic() {
const WIDTH: usize = 257;
const HEIGHT: usize = 33;
let rgb: Vec<u8> = (0..WIDTH * HEIGHT)
.flat_map(|i| {
let x = i % WIDTH;
let y = i / WIDTH;
let c = ((x / 8 + y / 8) & 15) as u8;
[c * 13, c * 7, c * 3]
})
.collect();
let rgba: Vec<u8> = rgb
.as_chunks::<3>()
.0
.iter()
.flat_map(|pixel| [pixel[0], pixel[1], pixel[2], 255 - pixel[0]])
.collect();
let one = lossless().with_speed(Speed::Slow).with_num_threads(1);
let many = lossless().with_speed(Speed::Slow).with_num_threads(4);
assert_eq!(
encode_image(&rgb, WIDTH, HEIGHT, &one).unwrap(),
encode_image(&rgb, WIDTH, HEIGHT, &many).unwrap()
);
assert_eq!(
encode_image_with_alpha(&rgba, WIDTH, HEIGHT, &one).unwrap(),
encode_image_with_alpha(&rgba, WIDTH, HEIGHT, &many).unwrap()
);
}
#[test]
fn rgb8_quality() {
ok(encode_image(
&rgb8(),
W,
H,
&EncodeConfig::default().with_quality(85.0),
));
}
#[test]
fn rgba8_lossy() {
ok(encode_image_with_alpha(&rgba8(), W, H, &lossy()));
}
#[test]
fn rgba8_lossless() {
ok(encode_image_with_alpha(&rgba8(), W, H, &lossless()));
}
#[test]
fn rgb16_lossy() {
ok(encode_image_16bit(&rgb16(), W, H, &lossy()));
}
#[test]
fn rgb16_lossless() {
ok(encode_image_16bit(&rgb16(), W, H, &lossless()));
}
#[test]
fn rgba16_lossy() {
ok(encode_image_with_alpha_16bit(&rgba16(), W, H, &lossy()));
}
#[test]
fn rgba16_lossless() {
ok(encode_image_with_alpha_16bit(&rgba16(), W, H, &lossless()));
}
#[test]
fn rgb10_lossy() {
ok(encode_image_10bit(&rgb10(), W, H, &lossy()));
}
#[test]
fn rgb10_lossless() {
ok(encode_image_10bit(&rgb10(), W, H, &lossless()));
}
#[test]
fn rgba10_lossy() {
ok(encode_image_with_alpha_10bit(&rgba10(), W, H, &lossy()));
}
#[test]
fn rgba10_lossless() {
ok(encode_image_with_alpha_10bit(&rgba10(), W, H, &lossless()));
}
#[test]
fn rgb12_lossy() {
ok(encode_image_12bit(&rgb12(), W, H, &lossy()));
}
#[test]
fn rgb12_lossless() {
ok(encode_image_12bit(&rgb12(), W, H, &lossless()));
}
#[test]
fn rgba12_lossy() {
ok(encode_image_with_alpha_12bit(&rgba12(), W, H, &lossy()));
}
#[test]
fn rgba12_lossless() {
ok(encode_image_with_alpha_12bit(&rgba12(), W, H, &lossless()));
}
#[test]
fn rgb_f32_lossy() {
ok(encode_image_f32(&rgb_f32(), W, H, &lossy()));
}
#[test]
fn rgb_f16_lossy() {
ok(encode_image_f16(&rgb_f32(), W, H, &lossy()));
}
#[test]
fn rgba_f32_lossy() {
ok(encode_image_with_alpha_f32(&rgba_f32(), W, H, &lossy()));
}
#[test]
fn rgba_f16_lossy() {
ok(encode_image_with_alpha_f16(&rgba_f32(), W, H, &lossy()));
}
#[test]
fn gray8_lossy() {
ok(encode_image_gray(&gray8(), W, H, &lossy()));
}
#[test]
fn gray8_lossless() {
ok(encode_image_gray(&gray8(), W, H, &lossless()));
}
#[test]
fn gray_alpha8_lossy() {
ok(encode_image_gray_alpha(&gray_alpha8(), W, H, &lossy()));
}
#[test]
fn gray_alpha8_lossless() {
ok(encode_image_gray_alpha(&gray_alpha8(), W, H, &lossless()));
}
#[test]
fn gray10_lossy() {
ok(encode_image_gray_10bit(&gray10(), W, H, &lossy()));
}
#[test]
fn gray10_lossless() {
ok(encode_image_gray_10bit(&gray10(), W, H, &lossless()));
}
#[test]
fn gray_alpha10_lossy() {
ok(encode_image_gray_alpha_10bit(
&gray_alpha10(),
W,
H,
&lossy(),
));
}
#[test]
fn gray_alpha10_lossless() {
ok(encode_image_gray_alpha_10bit(
&gray_alpha10(),
W,
H,
&lossless(),
));
}
#[test]
fn gray12_lossy() {
ok(encode_image_gray_12bit(&gray12(), W, H, &lossy()));
}
#[test]
fn gray12_lossless() {
ok(encode_image_gray_12bit(&gray12(), W, H, &lossless()));
}
#[test]
fn gray_alpha12_lossy() {
ok(encode_image_gray_alpha_12bit(
&gray_alpha12(),
W,
H,
&lossy(),
));
}
#[test]
fn gray_alpha12_lossless() {
ok(encode_image_gray_alpha_12bit(
&gray_alpha12(),
W,
H,
&lossless(),
));
}
#[test]
fn gray16_lossy() {
ok(encode_image_gray_16bit(&gray16(), W, H, &lossy()));
}
#[test]
fn gray16_lossless() {
ok(encode_image_gray_16bit(&gray16(), W, H, &lossless()));
}
#[test]
fn gray_alpha16_lossy() {
ok(encode_image_gray_alpha_16bit(
&gray_alpha16(),
W,
H,
&lossy(),
));
}
#[test]
fn gray_alpha16_lossless() {
ok(encode_image_gray_alpha_16bit(
&gray_alpha16(),
W,
H,
&lossless(),
));
}
#[test]
fn gray_f32_lossy() {
ok(encode_image_gray_f32(&gray_f32(), W, H, &lossy()));
}
#[test]
fn gray_f16_lossy() {
ok(encode_image_gray_f16(&gray_f32(), W, H, &lossy()));
}
#[test]
fn empty_width_rejected() {
assert!(matches!(
encode_image(&[], 0, H, &lossy()),
Err(EncodeError::EmptyImage)
));
}
#[test]
fn empty_height_rejected() {
assert!(matches!(
encode_image(&[], W, 0, &lossy()),
Err(EncodeError::EmptyImage)
));
}
#[test]
fn wrong_buffer_size_rejected() {
let short = vec![0u8; W * H]; assert!(matches!(
encode_image(&short, W, H, &lossy()),
Err(EncodeError::InputSizeMismatch { .. })
));
}
#[test]
fn invalid_distance_rejected() {
assert!(matches!(
encode_image(&rgb8(), W, H, &EncodeConfig::default().with_distance(-1.0)),
Err(EncodeError::InvalidDistance(_))
));
}
#[test]
fn dimension_too_large_rejected() {
let huge = MAX_DIMENSION + 1;
assert!(matches!(
encode_image(&[], huge, H, &lossy()),
Err(EncodeError::DimensionTooLarge { .. })
));
}
#[test]
fn one_by_one_rgb8() {
ok(encode_image(&[128u8, 64, 32], 1, 1, &lossy()));
}
#[test]
fn one_by_one_rgba8_lossless() {
ok(encode_image_with_alpha(
&[128u8, 64, 32, 255],
1,
1,
&lossless(),
));
}
#[test]
fn one_by_one_gray8() {
ok(encode_image_gray(&[200u8], 1, 1, &lossy()));
}
}