ndi-sdk-sys 0.1.1

Rust bindings for the NDI SDK
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

use std::{
    ffi::{CStr, CString},
    sync::Arc,
};

pub(crate) use crate::bindings::NDIlib_metadata_frame_t as NDIRawMetadataFrame;
use crate::{bindings, receiver::RawReceiver, sender::RawSender};

use super::{NDIFrame, RawBufferManagement, RawFrame, drop_guard::FrameDataDropGuard};

impl RawBufferManagement for NDIRawMetadataFrame {
    #[inline]
    unsafe fn drop_with_recv(&mut self, recv: &Arc<RawReceiver>) {
        unsafe { bindings::NDIlib_recv_free_metadata(recv.raw_ptr(), self) }
    }

    #[inline]
    unsafe fn drop_with_sender(&mut self, sender: &Arc<RawSender>) {
        unsafe { bindings::NDIlib_send_free_metadata(sender.raw_ptr(), self) }
    }

    fn assert_unwritten(&self) {
        assert!(
            self.p_data.is_null(),
            "[Fatal FFI Error] NDIRawMetadataFrame data is not null, but should be."
        );
    }
}

unsafe impl Send for NDIRawMetadataFrame {}
unsafe impl Sync for NDIRawMetadataFrame {}

impl RawFrame for NDIRawMetadataFrame {}

pub type MetadataFrame = NDIFrame<NDIRawMetadataFrame>;

impl MetadataFrame {
    pub fn new() -> Self {
        let raw = NDIRawMetadataFrame {
            timecode: bindings::NDIlib_send_timecode_synthesize,
            p_data: std::ptr::null_mut(),
            length: 0,
        };
        Self {
            raw,
            alloc: FrameDataDropGuard::NullPtr,
            custom_state: (),
        }
    }

    pub fn from_string(cstr: CString) -> Self {
        let raw = NDIRawMetadataFrame {
            timecode: bindings::NDIlib_send_timecode_synthesize,
            p_data: cstr.as_ptr() as *mut _,
            length: cstr.as_bytes_with_nul().len() as i32,
        };
        Self {
            raw,
            alloc: FrameDataDropGuard::CString(cstr),
            custom_state: (),
        }
    }

    pub fn to_str(&self) -> Option<&CStr> {
        if let FrameDataDropGuard::CString(cstr) = &self.alloc {
            return Some(cstr.as_c_str());
        }
        if self.raw.p_data.is_null() {
            None
        } else {
            let str = unsafe { CStr::from_ptr(self.raw.p_data as *const _) };
            if self.raw.length > 0 {
                assert_eq!(
                    str.to_bytes_with_nul().len(),
                    self.raw.length as usize,
                    "[Fatal FFI Error] NDIFrame::to_cstr: length mismatch"
                );
            }
            Some(str)
        }
    }

    // TODO: implement editing of metadata frames, otherwise this doesn't make much sense
    // pub fn dealloc(&mut self) {
    //     unsafe { self.alloc.drop_buffer(&mut self.raw) };
    //     self.raw.p_data = std::ptr::null_mut();
    //     self.raw.length = 0;
    // }
}

impl From<CString> for MetadataFrame {
    fn from(cstr: CString) -> Self {
        Self::from_string(cstr)
    }
}