webpx 0.2.0

Complete WebP encoding/decoding with ICC profiles, streaming, and animation support
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! Fuzz crash regression suite.
//!
//! Runs every file in `fuzz/regression/` through every public entry point that
//! has a fuzz target. Each seed file is a previously-found crash that has been
//! fixed; this test ensures none re-introduce a panic.
//!
//! Reproduces what the fuzz targets do, but as a regular `cargo test` — no
//! nightly toolchain required. Failures here mean a regression of a
//! previously-fixed bug.
//!
//! To add a new seed: drop the (preferably minimized) crash file into
//! `fuzz/regression/` with a `crash-<sha>` name, no other action required.

use std::fs;
use std::path::PathBuf;

const MAX_PIXEL_BYTES: usize = 256 * 1024 * 1024;

fn regression_dir() -> PathBuf {
    PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("fuzz/regression")
}

fn run_decode_static(input: &[u8]) {
    let _ = webpx::ImageInfo::from_webp(input);
    let info = match webpx::ImageInfo::from_webp(input) {
        Ok(i) => i,
        Err(_) => return,
    };
    let total_bytes = (info.width as usize)
        .saturating_mul(info.height as usize)
        .saturating_mul(4);
    if total_bytes > MAX_PIXEL_BYTES {
        return;
    }
    let _ = webpx::decode_rgba(input);
    let _ = webpx::decode_rgb(input);
    let _ = webpx::decode_bgra(input);
    let _ = webpx::decode_bgr(input);
    let _ = webpx::decode_yuv(input);
}

fn run_decoder_builder(input: &[u8]) {
    if let Ok(dec) = webpx::Decoder::new(input) {
        let _ = dec.decode_rgba();
    }
    if let Ok(dec) = webpx::Decoder::new(input) {
        let _ = dec.scale(32, 32).decode_rgba();
    }
    if let Ok(dec) = webpx::Decoder::new(input) {
        let _ = dec.crop(0, 0, 16, 16).decode_rgb();
    }
    // Edge cases the fuzzer reaches but a fixed harness misses: zero
    // scale and zero crop dimensions used to panic inside imgref instead
    // of returning Err. Make sure every seed exercises both.
    if let Ok(dec) = webpx::Decoder::new(input) {
        let _ = dec.scale(0, 0).decode_rgba();
    }
    if let Ok(dec) = webpx::Decoder::new(input) {
        let _ = dec.crop(0, 0, 0, 0).decode_rgba();
    }
}

fn run_streaming(input: &[u8]) {
    use webpx::{ColorMode, StreamingDecoder};
    if let Ok(mut dec) = StreamingDecoder::new(ColorMode::Rgba) {
        let _ = dec.append(input);
        let _ = dec.finish();
    }
}

fn run_animation(input: &[u8]) {
    if let Ok(mut dec) = webpx::AnimationDecoder::new(input) {
        let mut count = 0;
        while let Ok(Some(_frame)) = dec.next_frame() {
            count += 1;
            if count >= 64 {
                break;
            }
        }
    }
}

fn run_mux(input: &[u8]) {
    let _ = webpx::get_icc_profile(input);
    let _ = webpx::get_exif(input);
    let _ = webpx::get_xmp(input);
    let _ = webpx::remove_icc(input);
    let _ = webpx::remove_exif(input);
    let _ = webpx::remove_xmp(input);
    if let Ok(emb) = webpx::embed_icc(input, b"\x00\x00\x00\x00") {
        let _ = webpx::get_icc_profile(&emb);
    }
}

#[test]
fn fuzz_regression_seeds_do_not_panic() {
    let dir = regression_dir();
    let entries: Vec<_> = match fs::read_dir(&dir) {
        Ok(rd) => rd
            .filter_map(|e| e.ok())
            .filter(|e| e.file_type().map(|t| t.is_file()).unwrap_or(false))
            .collect(),
        Err(_) => Vec::new(),
    };

    if entries.is_empty() {
        eprintln!(
            "no regression seeds in {} — populate from fuzz crashes as they're discovered",
            dir.display()
        );
        return;
    }

    for entry in entries {
        let path = entry.path();
        let name = path
            .file_name()
            .and_then(|n| n.to_str())
            .unwrap_or("<unnamed>");
        let input = fs::read(&path).unwrap_or_else(|e| panic!("read {name}: {e}"));

        run_decode_static(&input);
        run_decoder_builder(&input);
        run_streaming(&input);
        run_animation(&input);
        run_mux(&input);

        eprintln!("ok: {name} ({} bytes)", input.len());
    }
}