121 lines
4.0 KiB
Rust
121 lines
4.0 KiB
Rust
use criterion::BenchmarkId;
|
|
use criterion::Throughput;
|
|
use criterion::{black_box, criterion_group, criterion_main, Criterion};
|
|
use image::imageops;
|
|
use image::GenericImageView;
|
|
use load_image as load_image_crate;
|
|
use stb_image::image::load as stb_load;
|
|
use stb_image::image::LoadResult;
|
|
|
|
use photosync::library::load_image;
|
|
use photosync::library::resize;
|
|
use photosync::library::save_to_jpeg_bytes;
|
|
use photosync::library::FilterType;
|
|
|
|
pub fn criterion_benchmark(c: &mut Criterion) {
|
|
const TEST_IMAGE_PATH: &'static str = "testdata/image.jpg";
|
|
let img = load_image(TEST_IMAGE_PATH, None, None).expect("failed to load test image");
|
|
|
|
c.bench_function("Load image", |b| {
|
|
b.iter(|| black_box(load_image(TEST_IMAGE_PATH, None, None)))
|
|
});
|
|
|
|
c.bench_function("Load image 256x256", |b| {
|
|
b.iter(|| black_box(load_image(TEST_IMAGE_PATH, Some(256), Some(256))))
|
|
});
|
|
|
|
c.bench_function("Load load_image", |b| {
|
|
b.iter(|| {
|
|
black_box(load_image_crate::load_image(TEST_IMAGE_PATH, true).expect("failed to load"))
|
|
})
|
|
});
|
|
c.bench_function("Load stb_image", |b| {
|
|
b.iter(|| match stb_load(TEST_IMAGE_PATH) {
|
|
LoadResult::Error(err) => panic!(err),
|
|
LoadResult::ImageU8(img) => {
|
|
black_box(img);
|
|
}
|
|
LoadResult::ImageF32(img) => {
|
|
black_box(img);
|
|
}
|
|
})
|
|
});
|
|
|
|
let mut group = c.benchmark_group("Resizing");
|
|
for size in [
|
|
(None, None),
|
|
(Some(256), Some(256)),
|
|
(Some(512), Some(512)),
|
|
(Some(1024), Some(1024)),
|
|
(Some(2048), Some(2048)),
|
|
]
|
|
.iter()
|
|
{
|
|
let (w, h) = size;
|
|
for filter in [
|
|
FilterType::Builtin(imageops::Nearest),
|
|
FilterType::Builtin(imageops::CatmullRom),
|
|
FilterType::Builtin(imageops::Lanczos3),
|
|
FilterType::Nearest,
|
|
]
|
|
.iter()
|
|
{
|
|
let (img_w, img_h) = img.dimensions();
|
|
let pixels = (img_w * img_h) as u64;
|
|
group.throughput(Throughput::Elements(pixels));
|
|
group.bench_with_input(
|
|
BenchmarkId::new(
|
|
format!("{:?}", filter),
|
|
format!(
|
|
"{}x{}",
|
|
w.map(|i| i.to_string()).unwrap_or("FULL".to_string()),
|
|
h.map(|i| i.to_string()).unwrap_or("FULL".to_string())
|
|
),
|
|
),
|
|
&(size, filter),
|
|
|b, (size, &filter)| b.iter(|| black_box(resize(&img, **size, filter))),
|
|
);
|
|
}
|
|
|
|
group.bench_with_input(
|
|
BenchmarkId::new(
|
|
"Save to bytes",
|
|
format!(
|
|
"{}x{}",
|
|
w.map(|i| i.to_string()).unwrap_or("FULL".to_string()),
|
|
h.map(|i| i.to_string()).unwrap_or("FULL".to_string())
|
|
),
|
|
),
|
|
size,
|
|
|b, size| {
|
|
let small_img = resize(&img, *size, FilterType::Builtin(imageops::Lanczos3));
|
|
b.iter(|| black_box(save_to_jpeg_bytes(&small_img)))
|
|
},
|
|
);
|
|
|
|
group.bench_with_input(
|
|
BenchmarkId::new(
|
|
"Full pipeline Lanczos3",
|
|
format!(
|
|
"{}x{}",
|
|
w.map(|i| i.to_string()).unwrap_or("FULL".to_string()),
|
|
h.map(|i| i.to_string()).unwrap_or("FULL".to_string())
|
|
),
|
|
),
|
|
size,
|
|
|b, size| {
|
|
b.iter(|| {
|
|
let img = load_image(TEST_IMAGE_PATH, size.0, size.1)
|
|
.expect("failed to load test image");
|
|
let small_img = resize(&img, *size, FilterType::Builtin(imageops::Lanczos3));
|
|
black_box(save_to_jpeg_bytes(&small_img))
|
|
})
|
|
},
|
|
);
|
|
}
|
|
group.finish();
|
|
}
|
|
|
|
criterion_group!(benches, criterion_benchmark);
|
|
criterion_main!(benches);
|