ndi-sdk 0.2.0

Dynamically-loading NDI SDK bindings
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use crate::sys::{NDIlib_find_create_t, NDIlib_find_instance_t};
use crate::{NDIError, NDIResult, Source, HANDLE};
use std::net::IpAddr;
use std::ptr;

#[derive(Default, Debug, Clone)]
pub struct FindSettings<'a> {
    show_local_sources: bool,
    groups: Vec<&'a str>,
    extra_ips: Vec<&'a IpAddr>,
}

impl<'a> FindSettings<'a> {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn show_local_sources(mut self, show: bool) -> Self {
        self.show_local_sources = show;
        self
    }

    pub fn add_group(mut self, group: &'a str) -> Self {
        self.groups.push(group);
        self
    }

    pub fn add_extra_ip(mut self, addr: &'a IpAddr) -> Self {
        self.extra_ips.push(addr);
        self
    }

    pub fn build(self) -> NDIResult<NDIlib_find_create_t> {
        let groups = self.groups.join(",");
        let ips = self
            .groups
            .iter()
            .map(|ip| ip.to_string())
            .collect::<Vec<_>>()
            .join(",");

        Ok(NDIlib_find_create_t {
            show_local_sources: self.show_local_sources,
            p_groups: if self.groups.is_empty() {
                ptr::null()
            } else {
                groups.as_ptr() as *const i8
            },
            p_extra_ips: if self.extra_ips.is_empty() {
                ptr::null()
            } else {
                ips.as_ptr() as *const i8
            },
        })
    }
}

pub struct FindInstance {
    inner: NDIlib_find_instance_t,
}
unsafe impl Send for FindInstance {}

impl Drop for FindInstance {
    fn drop(&mut self) {
        if let Some(destroy_fn) = unsafe { (*HANDLE.lib).find_destroy } {
            unsafe { destroy_fn(self.inner) };
        }
    }
}

impl FindInstance {
    pub fn create(settings: Option<&NDIlib_find_create_t>) -> NDIResult<FindInstance> {
        let create = match settings {
            Some(settings) => settings,
            None => ptr::null(),
        };
        let Some(create_fn) = (unsafe { (*HANDLE.lib).find_create_v2 }) else {
            return Err(NDIError::MissingSymbolV5("find_create_v2"));
        };

        let instance_ptr = unsafe { create_fn(create) };
        if instance_ptr.is_null() {
            return Err(NDIError::UnexpectedNullPointer("find_create_v2"));
        }
        Ok(FindInstance {
            inner: instance_ptr,
        })
    }

    pub fn get_current_sources(&mut self) -> NDIResult<Vec<Source>> {
        let Some(get_current_fn) = (unsafe { (*HANDLE.lib).find_get_current_sources }) else {
            return Err(NDIError::MissingSymbolV5("find_get_current_sources"));
        };

        let mut num_sources: u32 = 0;
        let sources_ptr = unsafe { get_current_fn(self.inner, &mut num_sources) };
        if num_sources == 0 {
            return Ok(Vec::new());
        }
        if sources_ptr.is_null() {
            return Err(NDIError::UnexpectedNullPointer("find_get_current_sources"));
        }
        let mut sources = Vec::new();
        for idx in 0..num_sources as usize {
            let source = unsafe { &*sources_ptr.add(idx) };
            sources.push(source.into());
        }
        Ok(sources)
    }

    pub fn wait_for_sources(&mut self, timeout_ms: u32) -> NDIResult<bool> {
        let Some(wait_fn) = (unsafe { (*HANDLE.lib).find_wait_for_sources }) else {
            return Err(NDIError::MissingSymbolV5("find_wait_for_sources"));
        };
        Ok(unsafe { wait_fn(self.inner, timeout_ms) })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_find() -> NDIResult<()> {
        let settings = FindSettings::new().show_local_sources(true).build()?;
        let mut inst = FindInstance::create(Some(&settings))?;
        let mut desired_sources = Vec::new();
        for _ in 0..3 {
            if !inst.wait_for_sources(5000)? {
                println!("No sources found!");
            } else {
                let sources = inst.get_current_sources()?;
                println!("Number of NDI Sources: {}", sources.len());
                for (idx, source) in sources.iter().enumerate() {
                    desired_sources.push(source);
                    println!("\tSource index: {}", idx);
                    println!("\t\tName: {}", source.ndi_name);
                    println!("\t\tURL:  {}", source.url_address);
                }
                // We'll just bail out early.
                break;
            }
        }
        Ok(())
    }
}