Expose filtering as a benchable API and add a benchmark for it

benches/filter.rs

@@ -0,0 +1,56 @@
+//! Usage example:
+//!
+//! ```
+//! $ alias bench="rustup run nightly cargo bench"
+//! $ bench --bench=filter --features=benchmarks,unstable -- --save-baseline my_baseline
+//! ... tweak something, say the Sub filter ...
+//! $ bench --bench=filter --features=benchmarks,unstable -- filter=Sub --baseline my_baseline
+//! ```
+
+use criterion::{criterion_group, criterion_main, Criterion, Throughput};
+use png::benchable_apis::filter;
+use png::FilterType;
+use rand::Rng;
+
+fn filter_all(c: &mut Criterion) {
+    let bpps = [1, 2, 3, 4, 6, 8];
+    let filters = [
+        FilterType::Sub,
+        FilterType::Up,
+        FilterType::Avg,
+        FilterType::Paeth,
+    ];
+    for &filter in filters.iter() {
+        for &bpp in bpps.iter() {
+            bench_filter(c, filter, bpp);
+        }
+    }
+}
+
+criterion_group!(benches, filter_all);
+criterion_main!(benches);
+
+fn bench_filter(c: &mut Criterion, filter: FilterType, bpp: u8) {
+    let mut group = c.benchmark_group("filter");
+
+    fn get_random_bytes<R: Rng>(rng: &mut R, n: usize) -> Vec<u8> {
+        use rand::Fill;
+        let mut result = vec![0u8; n];
+        result.as_mut_slice().try_fill(rng).unwrap();
+        result
+    }
+    let mut rng = rand::thread_rng();
+    let row_size = 4096 * (bpp as usize);
+    let two_rows = get_random_bytes(&mut rng, row_size * 2);
+
+    group.throughput(Throughput::Bytes(row_size as u64));
+    group.bench_with_input(
+        format!("filter={filter:?}/bpp={bpp}"),
+        &two_rows,
+        |b, two_rows| {
+            let (prev_row, curr_row) = two_rows.split_at(row_size);
+            let mut curr_row = curr_row.to_vec();
+            b.iter(|| filter(filter, bpp, prev_row, curr_row.as_mut_slice()));
+        },
+    );
+}

src/benchable_apis.rs

@@ -12,6 +12,11 @@ pub fn unfilter(filter: FilterType, tbpp: u8, previous: &[u8], current: &mut [u8
     crate::filter::unfilter(filter, tbpp, previous, current)
 }
 
+pub fn filter(filter: FilterType, tbpp: u8, previous: &[u8], current: &mut [u8]) {
+    let tbpp = BytesPerPixel::from_usize(tbpp as usize);
+    crate::filter::filter(filter, tbpp, previous, current)
+}
+
 pub use crate::decoder::transform::{create_transform_fn, TransformFn};
 
 pub fn create_info_from_plte_trns_bitdepth<'a>(