Add support for the new Amberella multsense camera

rust/libmultisense-ambarella/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "mswebrtc"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "mswebrtc"
+crate-type = ["staticlib"]
+
+[dependencies]
+qocrlif = { git = "ssh://git@github.com/carnegierobotics/qocrlif.git", rev = "cfc4a40acf1a90ea48a20655c92d917d3ed98e6a" }
+fragunfrag = { git = "ssh://git@github.com/carnegierobotics/fragunfrag.git", rev = "0f9ba8fb1cb0ed14cb154f694b6cc558d7720a3d" }
+str0m = "0.9.0"
+systemstat = "0.1.6"
+reqwest = {version="0.12.12", features=["blocking"]}
+serde = { version = "1.0.218", features = ["derive"] }
+serde_json = "1.0.139"
+
+[build-dependencies]
+cbindgen = "0.12"
+uuid = {version="1.16", features=["v4"]}

rust/libmultisense-ambarella/build.rs

@@ -0,0 +1,23 @@
+extern crate cbindgen;
+
+use uuid::Uuid;
+
+fn main() {
+    let mut output_file = std::env::current_dir().unwrap();
+    output_file.push(std::env::var("CARGO_TARGET_DIR").unwrap());
+    output_file.push("mswebrtc.h");
+
+    let b = cbindgen::Builder::new()
+        .with_include_guard(
+            "MSWEBRTC_H".to_owned()
+                + &Uuid::new_v4()
+                    .to_string()
+                    .to_uppercase()
+                    .split("-") //split and fold here because join is experimental
+                    .fold(String::new(), |a, b| a + "_" + b),
+        )
+        .with_crate(std::env::current_dir().unwrap());
+    b.generate()
+        .expect("Failed to generate bindings")
+        .write_to_file(output_file);
+}

rust/libmultisense-ambarella/src/lib.rs

@@ -0,0 +1,258 @@
+use reqwest::{self, StatusCode};
+use std::{ffi::CStr, net::UdpSocket, os::raw::c_char, str::Utf8Error};
+use str0m::{change::SdpOffer, Candidate, Rtc};
+use systemstat::{Platform, System};
+
+mod network;
+
+pub struct MswebrtcImpl {
+    host: String,
+    pc: Rtc,
+    sockets: Vec<UdpSocket>,
+}
+
+struct Info {
+    builddate: String,
+}
+
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct MswebrtcError {
+    what: String,
+    err: Option<Box<dyn std::error::Error>>,
+}
+
+impl MswebrtcImpl {
+    fn connect(&mut self) -> Result<(), MswebrtcError> {
+        let client = reqwest::blocking::Client::builder()
+            .danger_accept_invalid_certs(true)
+            .build()
+            .unwrap();
+        let offer = SdpOffer::from_sdp_string(
+            client
+                .get(self.host.clone() + "/offer")
+                .send()
+                .map_err(|e| MswebrtcError {
+                    what: "Failed to request offer".to_owned(),
+                    err: Some(Box::new(e)),
+                })?
+                .text()
+                .map_err(|e| MswebrtcError {
+                    what: "Failed to extract offer from HTTP response".to_owned(),
+                    err: Some(Box::new(e)),
+                })?
+                .as_str(),
+        )
+        .map_err(|e| MswebrtcError {
+            what: "Failed to parse offer".to_owned(),
+            err: Some(Box::new(e)),
+        })?;
+
+        //enumerate local ip addresses to enumerate ice candidates
+        {
+            let system = System::new();
+            let networks = system.networks().map_err(|e| MswebrtcError {
+                what: "Failed to enumarate networks".to_owned(),
+                err: Some(Box::new(e)),
+            })?;
+
+            let mut found = false;
+            for net in networks.values() {
+                for n in &net.addrs {
+                    if let systemstat::IpAddr::V4(v) = n.addr {
+                        if !v.is_loopback() && !v.is_link_local() && !v.is_broadcast() {
+                            let socket =
+                                UdpSocket::bind(format!("{v}:0")).map_err(|e| MswebrtcError {
+                                    what: "Failed to bind socket".to_owned(),
+                                    err: Some(Box::new(e)),
+                                })?;
+                            let candidate = Candidate::host(
+                                socket.local_addr().map_err(|e| MswebrtcError {
+                                    what: "failed to get address for socket".to_owned(),
+                                    err: Some(Box::new(e)),
+                                })?,
+                                "udp",
+                            )
+                            .map_err(|e| MswebrtcError {
+                                what: "Failed to create ICE candidate".to_owned(),
+                                err: Some(Box::new(e)),
+                            })?;
+                            if self.pc.add_local_candidate(candidate).is_some() {
+                                found = true;
+                                self.sockets.push(socket);
+                            }
+                        }
+                    }
+                }
+            }
+            if !found {
+                Err(MswebrtcError {
+		    what: "Failed to find valid local ICE candidate. Do we have any network interfaces?".to_owned(),
+		    err: None
+		})?
+            }
+        }
+        let answer = self
+            .pc
+            .sdp_api()
+            .accept_offer(offer)
+            .map_err(|e| MswebrtcError {
+                what: "Failed to accept RTC offer".to_owned(),
+                err: Some(Box::new(e)),
+            })?;
+
+        let answer = serde_json::to_string(&answer).map_err(|e| MswebrtcError {
+            what: "Failed to serialize answer".to_owned(),
+            err: Some(Box::new(e)),
+        })?;
+        client
+            .post(self.host.clone() + "/answer")
+            .header("content-type", "application/json")
+            .body(answer)
+            .send()
+            .map(|_| Ok(()))
+            .map_err(|e| MswebrtcError {
+                what: "Failed to post answer to server".to_owned(),
+                err: Some(Box::new(e)),
+            })?
+    }
+    fn disconnect(&self) {
+        println!("DISCONNECT");
+    }
+
+    fn get_info(&self) -> Result<Info, MswebrtcError> {
+        let client = reqwest::blocking::Client::builder()
+            .danger_accept_invalid_certs(true)
+            .build()
+            .unwrap();
+        let j = client
+            .get(self.host.clone() + "/info.json")
+            .send()
+            .map_err(|e| MswebrtcError {
+                what: "Failed to request offer".to_owned(),
+                err: Some(Box::new(e)),
+            })?;
+        let j = j.text().map_err(|e| MswebrtcError {
+            what: "Failed to extract offer from HTTP response".to_owned(),
+            err: Some(Box::new(e)),
+        })?;
+        let j: serde_json::Value = serde_json::from_str(j.as_str()).map_err(|e| MswebrtcError {
+            what: "Failed to parse info.json".to_owned(),
+            err: Some(Box::new(e)),
+        })?;
+        Ok(Info {
+            builddate: j["build-time"].to_string(),
+        })
+    }
+
+    fn set_network(&self, ns: network::Network) -> Result<(), MswebrtcError> {
+        let s = serde_json::to_string(&ns).map_err(|e| MswebrtcError {
+            what: format!("{:?}", &e),
+            err: Some(Box::new(e)),
+        })?;
+        let client = reqwest::blocking::Client::builder()
+            .danger_accept_invalid_certs(true)
+            .build()
+            .unwrap();
+        let j = client
+            .post(self.host.clone() + "/network.json")
+            .body(s)
+            .send()
+            .map_err(|e| MswebrtcError {
+                what: "Failed to set network".to_owned(),
+                err: Some(Box::new(e)),
+            })?;
+        match j.status() {
+            StatusCode::OK => Ok(()),
+            e => Err(MswebrtcError {
+                what: format!("Server failed to set network: {:?}", e),
+                err: None,
+            }),
+        }
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn create_mswebrtc_impl(host: *const std::ffi::c_char) -> *mut MswebrtcImpl {
+    let pc = Rtc::new();
+    let out = Box::new(MswebrtcImpl {
+        host: unsafe { std::ffi::CStr::from_ptr(host) }
+            .to_str()
+            .unwrap()
+            .to_string(),
+        pc: pc,
+        sockets: Vec::new(),
+    });
+    Box::into_raw(out)
+}
+
+#[no_mangle]
+pub extern "C" fn connect_mswebrtc_impl(obj: *mut MswebrtcImpl) -> bool {
+    let r = unsafe { &mut *obj };
+    match r.connect() {
+        Ok(_) => true,
+        Err(e) => {
+            println!("ERROR CONNECTING: {:?}", e);
+            false
+        }
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn get_info_mswebrtc_impl(
+    obj: *mut MswebrtcImpl,
+    mut buildtime: *mut std::ffi::c_char,
+) -> bool {
+    let r = unsafe { &*obj };
+    let i = r.get_info();
+    match i {
+        Ok(i) => {
+            for (i, c) in i.builddate.chars().enumerate() {
+                unsafe { *buildtime = c as std::ffi::c_char };
+                buildtime = buildtime.wrapping_add(1);
+                if i >= 31 {
+                    break;
+                }
+            }
+            true
+        }
+        Err(e) => {
+            println!("ERROR Getting Info: {:?}", e);
+            false
+        }
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn set_network_mswebrtc_impl(
+    obj: *mut MswebrtcImpl,
+    addr: *const c_char,
+    netmask: *const c_char,
+    gateway: *const c_char,
+) -> bool {
+    let n = || -> Result<Option<network::Network>, Utf8Error> {
+        Ok(network::Network::from_strings(
+            unsafe { CStr::from_ptr(addr) }.to_str()?,
+            unsafe { CStr::from_ptr(netmask) }.to_str()?,
+            unsafe { CStr::from_ptr(gateway) }.to_str()?,
+        ))
+    };
+    match n() {
+        Ok(Some(n)) => match unsafe { obj.as_mut() } {
+            Some(o) => o.set_network(n).is_ok(),
+            None => false,
+        },
+        _ => false,
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn disconnect_mswebrtc_impl(obj: *mut MswebrtcImpl) {
+    let r = unsafe { &*obj };
+    r.disconnect()
+}
+
+#[no_mangle]
+pub extern "C" fn destroy_mswebrtc_impl(obj: *mut MswebrtcImpl) {
+    drop(unsafe { Box::from_raw(obj) });
+}

rust/libmultisense-ambarella/src/network.rs

@@ -0,0 +1,51 @@
+use serde::{Deserialize, Serialize};
+use std::{net::Ipv4Addr, str::FromStr};
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct Network {
+    #[serde(rename(serialize = "ip-address", deserialize = "ip-address"))]
+    pub addr: String,
+    #[serde(rename(serialize = "netmask", deserialize = "netmask"))]
+    pub mask: u8,
+    pub gateway: Option<String>,
+}
+
+fn addr_to_cidr(addr: &str) -> Option<u8> {
+    let a = Ipv4Addr::from_str(addr);
+    match a {
+        Ok(a) => {
+            let b = a.to_bits();
+            let mut out = 32;
+            let mut i = 0;
+            while i < 32 {
+                if (b & (1 << i)) != 0 {
+                    break;
+                }
+                out -= 1;
+                i += 1;
+            }
+            while i < 32 {
+                if (b & (1 << i)) == 0 {
+                    return None;
+                }
+                i += 1;
+            }
+            Some(out)
+        }
+        Err(_) => None,
+    }
+}
+
+impl Network {
+    pub fn from_strings(addr: &str, mask: &str, gateway: &str) -> Option<Self> {
+        Some(Network {
+            addr: addr.to_string(),
+            mask: addr_to_cidr(mask)?,
+            gateway: if gateway.is_empty() {
+                None
+            } else {
+                Some(gateway.to_string())
+            },
+        })
+    }
+}