Files
photocraft/crates/codecs/tests/it/webp_lossy.rs
T
aiongg a6428d3dfb Build each crate's integration tests as one binary
Every tests/*.rs file is its own executable that links the whole crate
graph. Move each crate's test files into tests/it/ as modules of one
tests/it/main.rs; helper modules under tests/common move with them.

These keep their own binary (own process):
- engine panic_hunt: a process-wide panic hook counts every panic.
- engine text_gamma: changes the process-wide text gamma.
- engine smart_filter_stages, mask_cache_purge: assert on global caches.
- codecs pnm_peak_memory: reads the process's peak RSS.
- photocraft mac_menu_appkit: harness = false.
2026-10-22 16:55:34 +00:00

141 lines
6.5 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Lossy WebP (our VP8 encoder) checked against an independent decoder (`image-webp`): the
//! files decode, look like the input (PSNR by quality), get smaller as quality drops and are far
//! smaller than lossless on photographic content; alpha and metadata travel in the container;
//! odd sizes and the limits behave.
use crate::common;
use common::*;
use photocraft_codecs::*;
fn lossy(q: u8) -> EncodeOptions {
EncodeOptions { webp_lossless: false, webp_quality: q, ..Default::default() }
}
/// A smooth photograph-like image: gradients with a little grain.
fn photo(w: u32, h: u32, seed: u64) -> Image {
synth(w, h, ChannelLayout::Rgb, SampleType::U8, seed, 0.03)
}
#[test]
fn decodes_with_the_right_size_and_looks_like_the_input() {
let img = photo(97, 61, 3);
for (q, min_psnr) in [(100u8, 40.0), (90, 36.0), (75, 33.0), (50, 30.0), (20, 26.0)] {
let bytes = encode(&img, Format::WebP, &lossy(q)).unwrap();
let back = decode(&bytes).unwrap_or_else(|e| panic!("q{q}: {e}"));
assert_eq!(back.dimensions(), (97, 61));
assert_eq!(back.layout(), ChannelLayout::Rgb);
let p = psnr(&img, &back);
assert!(p >= min_psnr, "quality {q}: PSNR {p:.1} dB below {min_psnr}");
}
}
#[test]
fn smaller_at_lower_quality_and_much_smaller_than_lossless_on_photos() {
let img = synth(256, 192, ChannelLayout::Rgb, SampleType::U8, 9, 0.08);
let lossless = encode(&img, Format::WebP, &EncodeOptions::default()).unwrap().len();
let sizes: Vec<usize> = [95u8, 80, 60, 40, 20].iter().map(|&q| encode(&img, Format::WebP, &lossy(q)).unwrap().len()).collect();
for w in sizes.windows(2) {
assert!(w[1] <= w[0], "sizes must not grow as quality drops: {sizes:?}");
}
assert!(sizes[1] * 4 < lossless, "q80 {} vs lossless {lossless}", sizes[1]);
assert!(sizes[4] * 10 < lossless, "q20 {} vs lossless {lossless}", sizes[4]);
}
#[test]
fn flat_areas_cost_almost_nothing() {
// A single colour: every macroblock is skipped; the file is dominated by the header.
let img = Image::from_u8(640, 480, ChannelLayout::Rgb, vec![200u8; 640 * 480 * 3]).unwrap();
let bytes = encode(&img, Format::WebP, &lossy(80)).unwrap();
assert!(bytes.len() < 1200, "{} bytes", bytes.len());
let back = decode(&bytes).unwrap();
assert!(max_abs_diff(&img, &back) <= 3.0 / 255.0, "flat colour reproduced within rounding");
}
#[test]
fn alpha_is_kept_exactly_and_metadata_travels() {
let mut img = synth(40, 30, ChannelLayout::Rgba, SampleType::U8, 5, 0.05);
img.icc = Some(sample_icc(400));
img.meta.exif = Some(sample_exif());
img.meta.xmp = Some(SAMPLE_XMP.to_owned());
let bytes = encode(&img, Format::WebP, &lossy(85)).unwrap();
assert_eq!(&bytes[12..16], b"VP8X", "extended container");
let back = decode(&bytes).unwrap();
assert_eq!(back.layout(), ChannelLayout::Rgba);
for (a, b) in img.data().as_chunks::<4>().0.iter().zip(back.data().as_chunks::<4>().0) {
assert_eq!(a[3], b[3], "alpha is stored losslessly");
}
assert!(psnr(&img, &back) > 30.0);
assert_eq!(back.icc, img.icc);
assert!(back.meta.xmp.is_some());
assert!(back.meta.exif.is_some());
// Fully opaque alpha is dropped rather than stored.
let mut data = synth(40, 30, ChannelLayout::Rgba, SampleType::U8, 5, 0.0).data().to_vec();
for px in data.as_chunks_mut::<4>().0 {
px[3] = 255;
}
let opaque = Image::from_u8(40, 30, ChannelLayout::Rgba, data).unwrap();
let bytes = encode(&opaque, Format::WebP, &EncodeOptions { embed_icc: false, embed_metadata: false, ..lossy(85) }).unwrap();
assert_eq!(&bytes[12..16], b"VP8 ");
assert_eq!(decode(&bytes).unwrap().layout(), ChannelLayout::Rgb);
}
#[test]
fn gray_and_odd_sizes_and_tiny_images() {
for (w, h) in [(1, 1), (2, 3), (17, 9), (33, 1), (1, 47), (16, 16), (31, 15)] {
for layout in [ChannelLayout::Gray, ChannelLayout::GrayA, ChannelLayout::Rgb, ChannelLayout::Rgba] {
// Little noise: at these sizes the 2 × 2 chroma average alone would otherwise dominate.
let img = synth(w, h, layout, SampleType::U8, u64::from(w * 100 + h), 0.02);
let bytes = encode(&img, Format::WebP, &lossy(80)).unwrap_or_else(|e| panic!("{w}x{h} {layout:?}: {e}"));
let back = decode(&bytes).unwrap_or_else(|e| panic!("{w}x{h} {layout:?}: {e}"));
assert_eq!(back.dimensions(), (w, h));
// Below 8 px the 2 × 2 chroma average of random saturated pixels is the whole error.
if w >= 8 && h >= 8 {
let p = psnr(&img.convert(back.layout(), SampleType::U8), &back);
assert!(p > 24.0, "{w}x{h} {layout:?}: {p:.1} dB");
}
}
}
}
#[test]
fn sixteen_bit_input_is_quantised_to_eight() {
let img = synth(24, 24, ChannelLayout::Rgb, SampleType::U16, 2, 0.02);
let bytes = encode(&img, Format::WebP, &lossy(90)).unwrap();
let back = decode(&bytes).unwrap();
assert!(psnr(&img.convert(ChannelLayout::Rgb, SampleType::U8), &back) > 34.0);
}
#[test]
fn dimension_limit_is_an_error_not_a_panic() {
let img = Image::from_u8(16384, 1, ChannelLayout::Rgb, vec![0u8; 16384 * 3]).unwrap();
let e = encode(&img, Format::WebP, &lossy(50)).unwrap_err();
assert!(matches!(e, CodecError::Encode { .. }), "{e}");
let img = Image::from_u8(16383, 1, ChannelLayout::Rgb, vec![0u8; 16383 * 3]).unwrap();
let bytes = encode(&img, Format::WebP, &lossy(50)).unwrap();
assert_eq!(decode(&bytes).unwrap().dimensions(), (16383, 1));
}
#[test]
fn hard_edges_and_text_like_content_keep_their_structure() {
// Black text-like strokes on white: B_PRED sub-block modes keep edges sharp enough that the
// thresholded result matches the source almost everywhere.
let (w, h) = (128u32, 64u32);
let mut data = vec![255u8; (w * h * 3) as usize];
for y in 0..h {
for x in 0..w {
let stroke = (x % 11 < 2 && y > 8 && y < 56) || (y % 13 < 2 && x > 4 && x < 124);
if stroke {
let i = ((y * w + x) * 3) as usize;
data[i..i + 3].fill(0);
}
}
}
let img = Image::from_u8(w, h, ChannelLayout::Rgb, data).unwrap();
let bytes = encode(&img, Format::WebP, &lossy(90)).unwrap();
let back = decode(&bytes).unwrap();
let wrong = img.data().as_chunks::<3>().0.iter().zip(back.data().as_chunks::<3>().0).filter(|(a, b)| (a[0] < 128) != (b[0] < 128)).count();
let total = (w * h) as usize;
assert!(wrong * 100 < total * 2, "{wrong} of {total} pixels flipped side of mid-gray");
assert!(psnr(&img, &back) > 30.0, "{:.1}", psnr(&img, &back));
}