woff 0.6.3

The package provides a converter for Web Open Font Format.
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

//! [Web Open Font Format][1] of version 2.0.
//!
//! [1]: https://www.w3.org/TR/WOFF2/

mod ffi;

/// Compress.
pub fn compress<T>(data: &[u8], metadata: T, quality: usize, transform: bool) -> Option<Vec<u8>>
where
    T: Into<Vec<u8>>,
{
    let metadata = match std::ffi::CString::new(metadata) {
        Ok(metadata) => metadata,
        _ => return None,
    };
    let metadata_size = metadata.count_bytes();
    let size = unsafe {
        ffi::ComputeTTFToWOFF2Size(
            data.as_ptr() as *const _,
            data.len(),
            metadata.as_ptr() as *const _,
            metadata_size,
        )
    };
    let mut buffer = vec![0; size];
    let mut size = buffer.len();
    let status = unsafe {
        ffi::ConvertTTFToWOFF2(
            data.as_ptr() as *const _,
            data.len(),
            buffer.as_mut_ptr() as *mut _,
            &mut size as *mut _,
            metadata.as_ptr() as *const _,
            metadata_size,
            quality as core::ffi::c_int,
            transform as core::ffi::c_int,
        )
    };
    debug_assert_ne!(status, 0);
    if status == 0 {
        return None;
    }
    buffer.truncate(size);
    buffer.into()
}

/// Decompress.
pub fn decompress(data: &[u8]) -> Option<Vec<u8>> {
    let size = unsafe { ffi::ComputeWOFF2ToTTFSize(data.as_ptr() as *const _, data.len()) };
    let mut buffer = vec![0; size];
    let status = unsafe {
        ffi::ConvertWOFF2ToTTF(
            buffer.as_mut_ptr() as *mut _,
            size,
            data.as_ptr() as *const _,
            data.len(),
        )
    };
    debug_assert_ne!(status, 0);
    if status == 0 {
        return None;
    }
    buffer.into()
}

#[cfg(test)]
mod tests {
    use std::fs::{read, write};

    const DEFAULT_METADATA: &str = "";
    const DEFAULT_QUALITY: usize = 8;
    const DEFAULT_TRANSFORM: bool = true;

    macro_rules! ok(($result:expr) => ($result.unwrap()));

    #[test]
    fn otf() {
        ok!(write(
            "tests/fixtures/Roboto-Regular.otf.woff2",
            ok!(super::compress(
                &ok!(read("tests/fixtures/Roboto-Regular.otf")),
                DEFAULT_METADATA,
                DEFAULT_QUALITY,
                DEFAULT_TRANSFORM,
            )),
        ));
        ok!(write(
            "tests/fixtures/Roboto-Regular.otf",
            ok!(super::decompress(&ok!(read(
                "tests/fixtures/Roboto-Regular.otf.woff2"
            )))),
        ));
    }

    #[test]
    fn ttf() {
        ok!(write(
            "tests/fixtures/Roboto-Regular.ttf.woff2",
            ok!(super::compress(
                &ok!(read("tests/fixtures/Roboto-Regular.ttf")),
                DEFAULT_METADATA,
                DEFAULT_QUALITY,
                DEFAULT_TRANSFORM,
            )),
        ));
        ok!(write(
            "tests/fixtures/Roboto-Regular.ttf",
            ok!(super::decompress(&ok!(read(
                "tests/fixtures/Roboto-Regular.ttf.woff2"
            )))),
        ));
    }
}