c2pa 0.90.21

Rust SDK for C2PA (Coalition for Content Provenance and Authenticity) implementors
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

use std::{fs, io::Cursor, path::Path};

use c2pa::Reader;
use criterion::{criterion_group, criterion_main, Criterion};

fn load_signed(label: &str, ext: &str) -> Option<Vec<u8>> {
    let fixtures_dir = Path::new(env!("CARGO_MANIFEST_DIR")).join("benches/fixtures");
    let path = fixtures_dir.join(format!("{label}-signed.{ext}"));
    fs::read(&path).ok()
}

fn wide_assertions(c: &mut Criterion) {
    let Some(signed) = load_signed("wide-assertions", "c2pa") else {
        return;
    };
    c.bench_function("wide-assertions/read", |b| {
        b.iter(|| {
            let mut stream = Cursor::new(&signed);
            Reader::default().with_stream("application/c2pa", &mut stream)
        })
    });
}

fn wide_ingredients(c: &mut Criterion) {
    let Some(signed) = load_signed("wide-ingredients", "c2pa") else {
        return;
    };
    c.bench_function("wide-ingredients/read", |b| {
        b.iter(|| {
            let mut stream = Cursor::new(&signed);
            Reader::default().with_stream("application/c2pa", &mut stream)
        })
    });
}

fn deep_ingredients(c: &mut Criterion) {
    let Some(signed) = load_signed("deep-ingredients", "c2pa") else {
        return;
    };
    c.bench_function("deep-ingredients/read", |b| {
        b.iter(|| {
            let mut stream = Cursor::new(&signed);
            Reader::default().with_stream("application/c2pa", &mut stream)
        })
    });
}

fn update_manifests(c: &mut Criterion) {
    let Some(signed) = load_signed("update-manifests", "c2pa") else {
        return;
    };
    c.bench_function("update-manifests/read", |b| {
        b.iter(|| {
            let mut stream = Cursor::new(&signed);
            Reader::default().with_stream("application/c2pa", &mut stream)
        })
    });
}

fn large_cbor_assertion(c: &mut Criterion) {
    let Some(signed) = load_signed("large-cbor-assertion", "c2pa") else {
        return;
    };
    c.bench_function("large-cbor-assertion/read", |b| {
        b.iter(|| {
            let mut stream = Cursor::new(&signed);
            Reader::default().with_stream("application/c2pa", &mut stream)
        })
    });
}

fn large_json_assertion(c: &mut Criterion) {
    let Some(signed) = load_signed("large-json-assertion", "c2pa") else {
        return;
    };
    c.bench_function("large-json-assertion/read", |b| {
        b.iter(|| {
            let mut stream = Cursor::new(&signed);
            Reader::default().with_stream("application/c2pa", &mut stream)
        })
    });
}

fn binary_ingredient_tree(c: &mut Criterion) {
    let Some(signed) = load_signed("binary-ingredient-tree", "c2pa") else {
        return;
    };
    c.bench_function("binary-ingredient-tree/read", |b| {
        b.iter(|| {
            let mut stream = Cursor::new(&signed);
            Reader::default().with_stream("application/c2pa", &mut stream)
        })
    });
}

criterion_group!(
    benches,
    wide_assertions,
    wide_ingredients,
    deep_ingredients,
    update_manifests,
    large_cbor_assertion,
    large_json_assertion,
    binary_ingredient_tree,
);
criterion_main!(benches);