cadeau 0.5.2

Idiomatic rust bindings to Cadeau library, performance primitives and media foundation functions
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

use xmf_sys::{
    XmfVpxCodecType, XmfVpxDecoder, XmfVpxDecoderConfig, XmfVpxDecoder_Create, XmfVpxDecoder_Decode,
    XmfVpxDecoder_Destroy, XmfVpxDecoder_GetLastError, XmfVpxDecoder_GetNextFrame,
};

use crate::xmf::vpx::{VpxCodec, VpxError, VpxImage};

pub struct VpxDecoderBuilder {
    threads: u32,
    w: u32,
    h: u32,
    codec: VpxCodec,
}

pub struct VpxDecoder {
    // INVARIANT: A valid pointer to a properly initialized XmfVpxEncoder.
    // INVARIANT: The pointer is owned.
    ptr: *mut XmfVpxDecoder,
}

impl VpxDecoder {
    pub fn builder() -> VpxDecoderBuilder {
        VpxDecoderBuilder::new()
    }

    pub fn decode(&mut self, data: &[u8]) -> Result<(), VpxError> {
        // SAFETY: FFI call with no outstanding precondition.
        let ret = unsafe {
            XmfVpxDecoder_Decode(
                self.ptr,
                data.as_ptr(),
                u32::try_from(data.len()).map_err(|_| "data.len cannot be converted to u32")?,
            )
        };

        if ret == 0 {
            Ok(())
        } else {
            Err(self.last_error())
        }
    }

    pub fn next_frame(&mut self) -> Result<VpxImage<'_>, VpxError> {
        // SAFETY: FFI call with no outstanding precondition.
        let image = unsafe { XmfVpxDecoder_GetNextFrame(self.ptr) };

        if !image.is_null() {
            // SAFETY: Safe to call, the pointer is garanteed to be valid until the next call to the decoder.
            // and since the VpxImage have a lifetime tied to the VpxDecoder, it is safe to create and use it.
            Ok(unsafe { VpxImage::from_raw(image) })
        } else {
            Err(self.last_error())
        }
    }

    fn last_error(&self) -> VpxError {
        // SAFETY: Always safe to call, even if no error or no pointer.
        let error = unsafe { XmfVpxDecoder_GetLastError(self.ptr) };
        error.into()
    }
}

impl Drop for VpxDecoder {
    fn drop(&mut self) {
        // SAFETY: Safe to call, as the VpxDecoder owns the pointer.
        unsafe {
            XmfVpxDecoder_Destroy(self.ptr);
        };
    }
}

impl Default for VpxDecoderBuilder {
    fn default() -> Self {
        Self::new()
    }
}

impl VpxDecoderBuilder {
    pub fn new() -> Self {
        Self {
            threads: 0,
            w: 0,
            h: 0,
            codec: VpxCodec::VP8,
        }
    }

    #[must_use]
    pub fn threads(mut self, threads: u32) -> Self {
        self.threads = threads;
        self
    }

    #[must_use]
    pub fn width(mut self, width: u32) -> Self {
        self.w = width;
        self
    }

    #[must_use]
    pub fn height(mut self, height: u32) -> Self {
        self.h = height;
        self
    }

    #[must_use]
    pub fn codec(mut self, codec: VpxCodec) -> Self {
        self.codec = codec;
        self
    }

    pub fn build(self) -> Result<VpxDecoder, VpxError> {
        let config = XmfVpxDecoderConfig {
            threads: self.threads,
            w: self.w,
            h: self.h,
            codec: XmfVpxCodecType::from(self.codec),
        };

        // SAFETY: FFI call with no outstanding precondition.
        let ptr = unsafe { XmfVpxDecoder_Create(config) };

        if ptr.is_null() {
            return Err(VpxError::Internal("XmfVpxDecoder_Create returned null"));
        }

        Ok(VpxDecoder { ptr })
    }
}