Major changes to streaming protocol

This commit is contained in:
QuantumEntangledAndy authored and Andrew King committed 2022-12-14 09:59:57 +07:00
1 parent 2a0c2a2b46
commit 6fac0097dd
41 files changed
+1485 -1009

No files matched your search

+9 -7
View File
@@ -20,18 +20,20 @@ jobs:
- if: runner.os == 'Windows'
name: Install Gstreamer
run: |
choco install -y --no-progress gstreamer --version=1.16.2.20200527
choco install -y --no-progress gstreamer-devel --version=1.16.2
choco install -y --no-progress gstreamer --version=1.20.0
choco install -y --no-progress gstreamer-devel --version=1.20.0
echo "Updating Cargo environment"
echo "C:\gstreamer\1.0\x86_64\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
echo "GSTREAMER_1_0_ROOT_X86_64=C:\gstreamer\1.0\x86_64\" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
- if: runner.os == 'macOS'
name: Install Gstreamer on macOS
run: |
curl -L 'https://gstreamer.freedesktop.org/data/pkg/osx/1.16.2/gstreamer-1.0-devel-1.16.2-x86_64.pkg' -o "$(pwd)/gstreamer-devel.pkg"
curl -L 'https://gstreamer.freedesktop.org/data/pkg/osx/1.20.4/gstreamer-1.0-devel-1.20.4-universal.pkg' -o "$(pwd)/gstreamer-devel.pkg"
sudo installer -verbose -pkg "$(pwd)/gstreamer-devel.pkg" -target /
PKG_CONFIG_PATH="/Library/Frameworks/GStreamer.framework/Versions/1.0/lib/pkgconfig${PKG_CONFIG_PATH:+:$PKG_CONFIG_PATH}"
PKG_CONFIG_GSTREAMER_1_0_PREFIX /Library/Frameworks/GStreamer.framework/Versions/1.0
echo "PKG_CONFIG_PATH=${PKG_CONFIG_PATH}" >> "${GITHUB_ENV}"
echo "PKG_CONFIG_GSTREAMER_1_0_PREFIX=${PKG_CONFIG_GSTREAMER_1_0_PREFIX}" >> "${GITHUB_ENV}"
- name: Cache cargo registry
uses: actions/cache@v1
with:
@@ -102,10 +104,10 @@ jobs:
- name: Install ${{ matrix.arch }} Rust toolchain
uses: actions-rs/toolchain@v1
with:
toolchain: stable
override: true
target: ${{ matrix.target }}
profile: minimal
toolchain: stable
override: true
target: ${{ matrix.target }}
profile: minimal
- name: Build
uses: actions-rs/cargo@v1
with:
Generated
+6 -6
View File
@@ -269,9 +269,9 @@ dependencies = [
[[package]]
name = "crossbeam-channel"
version = "0.5.1"
version = "0.5.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "06ed27e177f16d65f0f0c22a213e17c696ace5dd64b14258b52f9417ccb52db4"
checksum = "c2dd04ddaf88237dc3b8d8f9a3c1004b506b54b3313403944054d23c0870c521"
dependencies = [
"cfg-if",
"crossbeam-utils",
@@ -1667,18 +1667,18 @@ dependencies = [
[[package]]
name = "thiserror"
version = "1.0.26"
version = "1.0.37"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "93119e4feac1cbe6c798c34d3a53ea0026b0b1de6a120deef895137c0529bfe2"
checksum = "10deb33631e3c9018b9baf9dcbbc4f737320d2b576bac10f6aefa048fa407e3e"
dependencies = [
"thiserror-impl",
]
[[package]]
name = "thiserror-impl"
version = "1.0.26"
version = "1.0.37"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "060d69a0afe7796bf42e9e2ff91f5ee691fb15c53d38b4b62a9a53eb23164745"
checksum = "982d17546b47146b28f7c22e3d08465f6b8903d0ea13c1660d9d84a6e7adcdbb"
dependencies = [
"proc-macro2",
"quote",
+12 -2
View File
@@ -45,7 +45,7 @@ fn github_ver() -> Option<String> {
}
}
#[cfg(windows)]
#[cfg(target_os = "windows")]
fn platform_cfg() {
let gstreamer_dir = env::var_os("GSTREAMER_1_0_ROOT_X86_64")
.and_then(|x| x.into_string().ok())
@@ -54,5 +54,15 @@ fn platform_cfg() {
println!(r"cargo:rustc-link-search=native={}\lib", gstreamer_dir);
}
#[cfg(not(windows))]
#[cfg(target_os = "macos")]
fn platform_cfg() {
let gstreamer_dir = env::var_os("GSTREAMER_1_0_ROOT_MACOSX")
.and_then(|x| x.into_string().ok())
.unwrap_or_else(|| r#"/Library/Frameworks/GStreamer.framework/Versions/1.0"#.to_string());
println!(r"cargo:rustc-link-search=native={}/lib", gstreamer_dir);
println!(r"cargo:rustc-link-arg=-Wl,-rpath,{}/lib", gstreamer_dir);
}
#[cfg(all(not(target_os = "macos"), not(target_os = "windows")))]
fn platform_cfg() {}
+1 -1
View File
@@ -10,7 +10,7 @@ aes = "0.6"
cfb-mode = "0.6"
cookie-factory = "0.3"
crc32fast = "1.2.1"
crossbeam-channel = "0.5.1"
crossbeam-channel = "0.5.6"
err-derive = "0.2"
get_if_addrs = "0.5.3"
lazy_static = "1.4"
+50 -46
View File
@@ -2,7 +2,10 @@ use crate::{bc, bcmedia};
use log::*;
use std::convert::TryInto;
use std::net::ToSocketAddrs;
use std::sync::atomic::{AtomicU16, Ordering};
use std::sync::{
atomic::{AtomicBool, AtomicU16, Ordering},
Mutex,
};
use Md5Trunc::*;
@@ -26,18 +29,19 @@ use bc::model::*;
pub(crate) use connection::*;
pub use errors::Error;
pub use ledstate::LightState;
pub use motion::{MotionOutput, MotionOutputError, MotionStatus};
pub use motion::{MotionData, MotionStatus};
pub use pirstate::PirState;
pub use resolution::*;
pub use stream::{Stream, StreamOutput, StreamOutputError};
use std::sync::Arc;
pub use stream::{Stream, StreamData};
type Result<T> = std::result::Result<T, Error>;
impl From<std::sync::mpsc::RecvTimeoutError> for Error {
fn from(k: std::sync::mpsc::RecvTimeoutError) -> Self {
impl From<crossbeam_channel::RecvTimeoutError> for Error {
fn from(k: crossbeam_channel::RecvTimeoutError) -> Self {
match k {
std::sync::mpsc::RecvTimeoutError::Timeout => Error::Timeout,
std::sync::mpsc::RecvTimeoutError::Disconnected => Error::TimeoutDisconnected,
crossbeam_channel::RecvTimeoutError::Timeout => Error::Timeout,
crossbeam_channel::RecvTimeoutError::Disconnected => Error::TimeoutDisconnected,
}
}
}
@@ -47,11 +51,11 @@ impl From<std::sync::mpsc::RecvTimeoutError> for Error {
///
pub struct BcCamera {
channel_id: u8,
connection: Option<BcConnection>,
logged_in: bool,
connection: Arc<BcConnection>,
logged_in: AtomicBool,
message_num: AtomicU16,
// Certain commands such as logout require the username/pass in plain text.... why....???
credentials: Option<Credentials>,
credentials: Mutex<Option<Credentials>>,
}
// Used for caching the credentials
@@ -182,31 +186,29 @@ impl BcCamera {
debug!("Success");
let me = Self {
connection: Some(conn),
connection: Arc::new(conn),
message_num: AtomicU16::new(0),
channel_id,
logged_in: false,
credentials: None,
logged_in: AtomicBool::new(false),
credentials: Mutex::new(None),
};
if let Some(conn) = &me.connection {
if conn.is_udp() {
let keep_alive_msg = Bc {
meta: BcMeta {
msg_id: MSG_ID_UDP_KEEP_ALIVE,
channel_id: me.channel_id,
msg_num: me.new_message_num(),
stream_type: 0,
response_code: 0,
class: 0x6414,
},
body: BcBody::ModernMsg(ModernMsg {
..Default::default()
}),
};
if me.connection.is_udp() {
let keep_alive_msg = Bc {
meta: BcMeta {
msg_id: MSG_ID_UDP_KEEP_ALIVE,
channel_id: me.channel_id,
msg_num: me.new_message_num(),
stream_type: 0,
response_code: 0,
class: 0x6414,
},
body: BcBody::ModernMsg(ModernMsg {
..Default::default()
}),
};
conn.set_keep_alive_msg(keep_alive_msg);
}
me.connection.set_keep_alive_msg(keep_alive_msg);
}
Ok(me)
}
@@ -216,35 +218,37 @@ impl BcCamera {
self.message_num.fetch_add(1, Ordering::Relaxed)
}
fn get_connection(&self) -> Arc<BcConnection> {
self.connection.clone()
}
/// This will drop the connection. It will try to send the logout request to the camera
/// first
pub fn disconnect(&mut self) {
if let Some(connection) = &self.connection {
// Stop polling now. We don't need it for a disconnect
//
// It will also ensure that when we drop the connection we don't
// get an error for read return zero bytes from the polling thread;
connection.stop_polling();
if let Err(err) = self.logout() {
warn!("Could not log out, ignoring: {}", err);
}
let connection = &self.connection;
// Stop polling now. We don't need it for a disconnect
//
// It will also ensure that when we drop the connection we don't
// get an error for read return zero bytes from the polling thread;
connection.stop_polling();
if let Err(err) = self.logout() {
warn!("Could not log out, ignoring: {}", err);
}
self.connection = None;
}
// Certains commands like logout need the username and password
// this command will return it as a tuple of (Username, Option<Password>)
// This will only work after login
fn get_credentials(&self) -> &Option<Credentials> {
&self.credentials
fn get_credentials(&self) -> Option<Credentials> {
self.credentials.lock().unwrap().clone()
}
// This is used to store the credentials it is called during login.
fn set_credentials(&mut self, username: String, password: Option<String>) {
self.credentials = Some(Credentials::new(username, password));
fn set_credentials(&self, username: String, password: Option<String>) {
*(self.credentials.lock().unwrap()) = Some(Credentials::new(username, password));
}
// This is used to clear the stored credentials it is called during logout.
fn clear_credentials(&mut self) {
self.credentials = None;
fn clear_credentials(&self) {
*(self.credentials.lock().unwrap()) = None;
}
}
@@ -1,6 +1,7 @@
use super::{BcSource, BcSubscription, Error, Result, TcpSource};
use crate::bc;
use crate::bc::model::*;
use crossbeam_channel::{unbounded, Receiver, Sender};
use log::*;
use socket2::{Domain, Socket, Type};
use std::collections::btree_map::Entry;
@@ -8,7 +9,6 @@ use std::collections::BTreeMap;
use std::error::Error as StdErr; // Just need the traits
use std::io::{Error as IoError, Read, Write};
use std::net::{SocketAddr, TcpStream};
use std::sync::mpsc::{channel, Receiver, Sender};
use std::sync::{atomic::AtomicBool, atomic::Ordering, Arc, Mutex};
use std::thread::JoinHandle;
use std::time::{Duration, Instant};
@@ -98,7 +98,7 @@ impl BcConnection {
#[allow(clippy::significant_drop_in_scrutinee)]
pub fn subscribe(&self, msg_num: u16) -> Result<BcSubscription> {
let (tx, rx) = channel();
let (tx, rx) = unbounded();
match self.subscribers.lock().unwrap().entry(msg_num) {
Entry::Vacant(vac_entry) => vac_entry.insert(tx),
Entry::Occupied(_) => return Err(Error::SimultaneousSubscription { msg_num }),
@@ -1,6 +1,6 @@
use super::{BcConnection, Result};
use crate::bc::model::*;
use std::sync::mpsc::Receiver;
use crossbeam_channel::Receiver;
pub struct BcSubscription<'a> {
pub rx: Receiver<Bc>,
@@ -3,10 +3,8 @@ use super::{
BcConnection,
};
use crate::bc::model::*;
use std::{
io::{BufRead, Error, ErrorKind, Read},
sync::mpsc::RecvTimeoutError,
};
use crossbeam_channel::RecvTimeoutError;
use std::io::{BufRead, Error, ErrorKind, Read};
type Result<T> = std::result::Result<T, Error>;
@@ -9,6 +9,7 @@ use crate::bc;
use crate::bc::model::*;
use crate::bcmedia;
use crate::bcudp;
use crossbeam_channel::{unbounded, Receiver, RecvError, Sender};
use err_derive::Error;
use log::*;
use socket2::{Domain, Socket, Type};
@@ -16,7 +17,6 @@ use std::collections::btree_map::Entry;
use std::collections::BTreeMap;
use std::error::Error as StdErr; // Just need the traits
use std::net::{SocketAddr, TcpStream};
use std::sync::mpsc::{channel, Receiver, RecvError, Sender};
use std::sync::{atomic::AtomicBool, atomic::Ordering, Arc, Mutex};
use std::thread::JoinHandle;
@@ -1,6 +1,7 @@
use super::{BcSubscription, Error, Result};
use crate::bc;
use crate::bc::model::*;
use crossbeam_channel::{unbounded, Receiver, Sender};
use log::*;
use socket2::{Domain, Socket, Type};
use std::collections::btree_map::Entry;
@@ -8,7 +9,6 @@ use std::collections::BTreeMap;
use std::error::Error as StdErr; // Just need the traits
use std::io::{Error as IoError, Read, Write};
use std::net::{SocketAddr, TcpStream};
use std::sync::mpsc::{channel, Receiver, Sender};
use std::sync::{atomic::AtomicBool, atomic::Ordering, Arc, Mutex};
use std::thread::JoinHandle;
use std::time::Duration;
+5 -1
View File
@@ -40,7 +40,11 @@ pub enum Error {
/// Raised when a connection is dropped.
#[error(display = "Dropped connection")]
DroppedConnection(#[error(source)] std::sync::mpsc::RecvError),
DroppedConnection(#[error(source)] crossbeam_channel::RecvError),
/// Raised when a connection is dropped during a TryRecv event
#[error(display = "Dropped connection")]
DroppedConnectionTry(#[error(source)] crossbeam_channel::TryRecvError),
/// Raised when the RX_TIMEOUT is reach
#[error(display = "Timeout")]
+2 -8
View File
@@ -4,10 +4,7 @@ use crate::bc::{model::*, xml::*};
impl BcCamera {
/// Get the [LedState] xml which contains the LED status of the camera
pub fn get_ledstate(&self) -> Result<LedState> {
let connection = self
.connection
.as_ref()
.expect("Must be connected to get time");
let connection = self.get_connection();
let msg_num = self.new_message_num();
let sub_get = connection.subscribe(msg_num)?;
let get = Bc {
@@ -54,10 +51,7 @@ impl BcCamera {
/// Set the led lights using the [LedState] xml
pub fn set_ledstate(&self, mut led_state: LedState) -> Result<()> {
let connection = self
.connection
.as_ref()
.expect("Must be connected to get time");
let connection = self.get_connection();
let msg_num = self.new_message_num();
let sub_set = connection.subscribe(msg_num)?;
+4 -6
View File
@@ -1,18 +1,16 @@
use super::{make_aes_key, md5_string, BcCamera, Error, Result, Truncate, ZeroLast, RX_TIMEOUT};
use crate::bc::{model::*, xml::*};
use std::sync::atomic::Ordering;
impl BcCamera {
/// Login to the camera.
///
/// This should be called before most other commands
pub fn login(&mut self, username: &str, password: Option<&str>) -> Result<DeviceInfo> {
pub fn login(&self, username: &str, password: Option<&str>) -> Result<DeviceInfo> {
let device_info;
// This { is here due to the connection and set_credentials both requiring a mutable borrow
{
let connection = self
.connection
.as_ref()
.expect("Must be connected to log in");
let connection = self.get_connection();
let msg_num = self.new_message_num();
let sub_login = connection.subscribe(msg_num)?;
@@ -119,7 +117,7 @@ impl BcCamera {
..
}) => {
// Login succeeded!
self.logged_in = true;
self.logged_in.store(true, Ordering::Relaxed);
device_info = info;
}
BcBody::ModernMsg(ModernMsg {
+5 -7
View File
@@ -1,15 +1,13 @@
use super::{BcCamera, Result};
use crate::bc::{model::*, xml::*};
use std::sync::atomic::Ordering;
impl BcCamera {
/// Logout from the camera
pub fn logout(&mut self) -> Result<()> {
if self.logged_in {
pub fn logout(&self) -> Result<()> {
if self.logged_in.load(Ordering::Relaxed) {
if let Some(credentials) = self.get_credentials() {
let connection = self
.connection
.as_ref()
.expect("Must be connected to log in");
let connection = self.get_connection();
let msg_num = self.new_message_num();
let sub_logout = connection.subscribe(msg_num)?;
@@ -41,7 +39,7 @@ impl BcCamera {
}
}
self.clear_credentials();
self.logged_in = false;
self.logged_in.store(false, Ordering::Relaxed);
Ok(())
}
}
+129 -65
View File
@@ -1,40 +1,95 @@
use super::{BcCamera, Error, Result, RX_TIMEOUT};
use crate::bc::{model::*, xml::*};
use crossbeam_channel::{bounded, Receiver, TryRecvError};
use std::sync::{
atomic::{AtomicBool, Ordering},
Arc,
};
use std::thread::{self, JoinHandle};
use std::time::{Duration, Instant};
/// Motion Status that the callback can send
#[derive(Clone, Copy, Debug)]
pub enum MotionStatus {
/// Sent when motion is first detected
Start,
Start(Instant),
/// Sent when motion stops
Stop,
Stop(Instant),
/// Sent when an Alarm about something other than motion was received
NoChange,
NoChange(Instant),
}
/// This is a conveince type for the error of the MotionOutput callback
pub type MotionOutputError = Result<bool>;
/// A handle on current motion related events comming from the camera
///
/// When this object is dropped the motion events are stopped
pub struct MotionData {
handle: Option<JoinHandle<Result<()>>>,
rx: Receiver<MotionStatus>,
abort_handle: Arc<AtomicBool>,
last_update: MotionStatus,
}
/// Trait used as part of [`listen_on_motion`] to send motion messages
pub trait MotionOutput {
/// This is the callback used when motion is received
impl MotionData {
/// Get if motion has been detected. Returns None if
/// no motion data has yet been recieved from the camera
///
/// If result is `Ok(true)` more messages will be sent
/// An error is raised if the motion connection to the camera is dropped
pub fn motion_detected(&mut self) -> Result<Option<bool>> {
self.consume_motion_events()?;
Ok(match &self.last_update {
MotionStatus::Start(_) => Some(true),
MotionStatus::Stop(_) => Some(false),
MotionStatus::NoChange(_) => None,
})
}
/// Get if motion has been detected within given duration. Returns None if
/// no motion data has yet been recieved from the camera
///
/// If result if `Ok(false)` then message will be stopped
/// An error is raised if the motion connection to the camera is dropped
pub fn motion_detected_within(&mut self, duration: Duration) -> Result<Option<bool>> {
self.consume_motion_events()?;
Ok(match &self.last_update {
MotionStatus::Start(time) => Some((Instant::now() - *time) < duration),
MotionStatus::Stop(time) => Some((Instant::now() - *time) < duration),
MotionStatus::NoChange(_) => None,
})
}
/// Consume the motion events diretly
///
/// If result is `Err(E)` then motion messages be stopped
/// and an error will be thrown
fn motion_recv(&mut self, motion_status: MotionStatus) -> MotionOutputError;
/// An error is raised if the motion connection to the camera is dropped
pub fn consume_motion_events(&mut self) -> Result<Vec<MotionStatus>> {
let mut results: Vec<MotionStatus> = vec![];
loop {
match self.rx.try_recv() {
Ok(motion) => results.push(motion),
Err(TryRecvError::Empty) => break,
Err(e) => return Err(Error::from(e)),
}
}
for res in results.iter() {
log::info!("Mption: {:?}", res);
}
if let Some(last) = results.last() {
self.last_update = *last;
}
Ok(results)
}
}
impl Drop for MotionData {
fn drop(&mut self) {
self.abort_handle.store(true, Ordering::Relaxed);
self.handle.take().map(|h| h.join());
}
}
impl BcCamera {
/// This message tells the camera to send the motion events to us
/// Which are the recieved on msgid 33
fn start_motion_query(&self) -> Result<u16> {
let connection = self
.connection
.as_ref()
.expect("Must be connected to listen to messages");
let connection = self.get_connection();
let msg_num = self.new_message_num();
let sub = connection.subscribe(msg_num)?;
@@ -69,65 +124,74 @@ impl BcCamera {
}
}
/// This requests that motion messages be listen to and sent to the
/// output struct.
///
/// The output structure must implement the [`MotionCallback`] trait
pub fn listen_on_motion<T: MotionOutput>(&self, data_out: &mut T) -> Result<()> {
/// This returns a data structure which can be used to
/// query motion events
pub fn listen_on_motion(&self) -> Result<MotionData> {
let msg_num = self.start_motion_query()?;
let connection = self
.connection
.as_ref()
.expect("Must be connected to listen to messages");
let connection = self.get_connection();
// After start_motion_query (MSG_ID 31) the camera sends motion messages
// when whenever motion is detected.
let sub = connection.subscribe(msg_num)?;
let abort_handle = Arc::new(AtomicBool::new(false));
let (tx, rx) = bounded(20);
loop {
// Mostly ignore when timout is reached because these messages are only
// sent when motion is detected which might means hours between messages
// being received
let msg = sub.rx.recv_timeout(RX_TIMEOUT);
let status = match msg {
Ok(motion_msg) => {
if let BcBody::ModernMsg(ModernMsg {
payload:
Some(BcPayloads::BcXml(BcXml {
alarm_event_list: Some(alarm_event_list),
..
})),
..
}) = motion_msg.body
{
let mut result = MotionStatus::NoChange;
for alarm_event in &alarm_event_list.alarm_events {
if alarm_event.channel_id == self.channel_id {
if alarm_event.status == "MD" {
result = MotionStatus::Start;
break;
} else if alarm_event.status == "none" {
result = MotionStatus::Stop;
break;
let abort_handle_thread = abort_handle.clone();
let channel_id = self.channel_id;
let handle = thread::spawn(move || {
let sub = connection.subscribe(msg_num)?;
while !abort_handle_thread.load(Ordering::Relaxed) {
let msg = sub.rx.recv_timeout(RX_TIMEOUT);
let status = match msg {
Ok(motion_msg) => {
if let BcBody::ModernMsg(ModernMsg {
payload:
Some(BcPayloads::BcXml(BcXml {
alarm_event_list: Some(alarm_event_list),
..
})),
..
}) = motion_msg.body
{
let mut result = MotionStatus::NoChange(Instant::now());
for alarm_event in &alarm_event_list.alarm_events {
if alarm_event.channel_id == channel_id {
if alarm_event.status == "MD" {
result = MotionStatus::Start(Instant::now());
break;
} else if alarm_event.status == "none" {
result = MotionStatus::Stop(Instant::now());
break;
}
}
}
Ok(result)
} else {
Ok(MotionStatus::NoChange(Instant::now()))
}
Ok(result)
} else {
Ok(MotionStatus::NoChange)
}
}
Err(std::sync::mpsc::RecvTimeoutError::Timeout) => Ok(MotionStatus::NoChange),
// On connection drop we stop
Err(e @ std::sync::mpsc::RecvTimeoutError::Disconnected) => Err(e),
}?;
Err(crossbeam_channel::RecvTimeoutError::Timeout) => {
Ok(MotionStatus::NoChange(Instant::now()))
}
// On connection drop we stop
Err(e @ crossbeam_channel::RecvTimeoutError::Disconnected) => Err(e),
}?;
match data_out.motion_recv(status) {
Ok(true) => {}
Ok(false) => return Ok(()),
Err(e) => return Err(e),
if tx.send(status).is_err() {
// Motion reciever has been dropped
abort_handle_thread.store(true, Ordering::Relaxed);
break;
}
}
}
Ok(())
});
Ok(MotionData {
handle: Some(handle),
rx,
abort_handle,
last_update: MotionStatus::NoChange(Instant::now()),
})
}
}
+1 -1
View File
@@ -5,7 +5,7 @@ impl BcCamera {
/// Ping the camera will either return Ok(()) which means a sucess reply
/// or error
pub fn ping(&self) -> Result<()> {
let connection = self.connection.as_ref().expect("Must be connected to ping");
let connection = self.get_connection();
let msg_num = self.new_message_num();
let sub_ping = connection.subscribe(msg_num)?;
+2 -8
View File
@@ -4,10 +4,7 @@ use crate::bc::{model::*, xml::*};
impl BcCamera {
/// Get the [RfAlarmCfg] xml which contains the PIR status of the camera
pub fn get_pirstate(&mut self) -> Result<RfAlarmCfg> {
let connection = self
.connection
.as_ref()
.expect("Must be connected to get time");
let connection = self.get_connection();
let msg_num = self.new_message_num();
let sub_get = connection.subscribe(msg_num)?;
let get = Bc {
@@ -54,10 +51,7 @@ impl BcCamera {
/// Set the PIR sensor using the [RfAlarmCfg] xml
pub fn set_pirstate(&mut self, rf_alarm_cfg: RfAlarmCfg) -> Result<()> {
let connection = self
.connection
.as_ref()
.expect("Must be connected to get time");
let connection = self.get_connection();
let msg_num = self.new_message_num();
let sub_set = connection.subscribe(msg_num)?;
+1 -1
View File
@@ -4,7 +4,7 @@ use crate::bc::model::*;
impl BcCamera {
/// Reboot the camera
pub fn reboot(&self) -> Result<()> {
let connection = self.connection.as_ref().expect("Must be connected to ping");
let connection = self.get_connection();
let msg_num = self.new_message_num();
let sub = connection.subscribe(msg_num)?;
+144 -136
View File
@@ -3,30 +3,15 @@ use crate::{
bc::{model::*, xml::*},
bcmedia::model::*,
};
use crossbeam_channel::{bounded, unbounded, Receiver, TryRecvError};
use std::sync::{
atomic::{AtomicBool, Ordering},
Arc,
};
/// Convience type for the error raised by the [StreamOutput] trait
pub type StreamOutputError = Result<bool>;
/// The method [`BcCamera::start_video()`] requires a structure with this trait to pass the
/// audio and video data back to
pub trait StreamOutput {
/// This is the callback raised a complete media packet is received
///
/// If result is `Ok(true)` more messages will be sent
///
/// If result if `Ok(false)` then message will be stopped
///
/// If result is `Err(E)` then messages be stopped
/// and an error will be thrown
fn stream_recv(&mut self, media: BcMedia) -> StreamOutputError;
}
use std::thread::{self, JoinHandle};
/// The stream names supported by BC
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum Stream {
/// This is the HD stream
Main,
@@ -39,142 +24,165 @@ pub enum Stream {
Extern,
}
/// A handle on currently streaming data
///
/// The data can be pulled using `get_data` which returns raw BcMedia packets
///
/// When this object is dropped the streaming is stopped
pub struct StreamData<'a> {
camera: &'a BcCamera,
handle: Option<JoinHandle<Result<()>>>,
rx: Receiver<Result<BcMedia>>,
abort_handle: Arc<AtomicBool>,
stream: Stream,
}
impl<'a> StreamData<'a> {
/// Pull data from the camera's buffer
/// This returns raw BcMedia packets
pub fn get_data(&self) -> Result<Vec<Result<BcMedia>>> {
let mut results: Vec<_> = vec![];
loop {
match self.rx.try_recv() {
Ok(data) => results.push(data),
Err(TryRecvError::Empty) => break,
Err(e) => return Err(Error::from(e)),
}
}
Ok(results)
}
}
impl<'a> Drop for StreamData<'a> {
fn drop(&mut self) {
self.abort_handle.store(true, Ordering::Relaxed);
self.handle.take().map(|h| h.join());
let _ = self.camera.stop_video(self.stream);
}
}
impl BcCamera {
///
/// Starts the video stream
///
/// # Parameters
/// The returned object manages the data stream, when it is dropped
/// the video stop signal is sent to the camera
///
/// * `data_outs` - This should be a struct that implements the [`StreamOutput`] trait
/// To pull frames from the camera's buffer use `recv_data` on the returned object
///
/// * `stream_name` - This is a [`Stream`] that controls the stream to request from the camera.
/// Selecting [`Stream::Main`] will select the HD stream.
/// Selecting [`Stream::Sub`] will select the SD stream.
/// Selecting [`Stream::Extern`] will select the medium quality stream (only on some camera)
/// The buffer represents number of compete messages so 1 would be one complete message
/// which may be a single audio frame or a whole video key frame
/// A value of 0 means unlimited buffer size
///
/// # Returns
///
/// This will block forever or return an error when the camera connection is dropped
///
pub fn start_video<Outputs>(
&self,
data_outs: &mut Outputs,
stream: Stream,
abort_handle: Arc<AtomicBool>,
) -> Result<()>
where
Outputs: StreamOutput,
{
let connection = self
.connection
.as_ref()
.expect("Must be connected to start video");
pub fn start_video(&self, stream: Stream, buffer_size: usize) -> Result<StreamData<'_>> {
let connection = self.get_connection();
let msg_num = self.new_message_num();
let sub_video = connection.subscribe(msg_num)?;
let channel_id = self.channel_id;
// On an E1 and swann cameras:
// - mainStream always has a value of 0
// - subStream always has a value of 1
// - There is no externStram
// On a B800:
// - mainStream is 0
// - subStream is 0
// - externStream is 0
let stream_code = match stream {
Stream::Main => 0,
Stream::Sub => 1,
Stream::Extern => 0,
let abort_handle = Arc::new(AtomicBool::new(false));
let (tx, rx) = match buffer_size {
0 => unbounded(),
n => bounded(n),
};
// Theses are the numbers used with the offical client
// On an E1 and swann cameras:
// - mainStream always has a value of 0
// - subStream always has a value of 1
// - There is no externStram
// On a B800:
// - mainStream is 0
// - subStream is 256
// - externStram is 1024
let handle = match stream {
Stream::Main => 0,
Stream::Sub => 256,
Stream::Extern => 1024,
};
let abort_handle_thread = abort_handle.clone();
let handle = thread::spawn(move || {
let sub_video = connection.subscribe(msg_num)?;
let stream_name = match stream {
Stream::Main => "mainStream",
Stream::Sub => "subStream",
Stream::Extern => "externStream",
}
.to_string();
let start_video = Bc::new_from_xml(
BcMeta {
msg_id: MSG_ID_VIDEO,
channel_id: self.channel_id,
msg_num,
stream_type: stream_code,
response_code: 0,
class: 0x6414, // IDK why
},
BcXml {
preview: Some(Preview {
version: xml_ver(),
channel_id: self.channel_id,
handle,
stream_type: Some(stream_name),
}),
..Default::default()
},
);
sub_video.send(start_video)?;
let msg = sub_video.rx.recv_timeout(RX_TIMEOUT)?;
if let BcMeta {
response_code: 200, ..
} = msg.meta
{
} else {
return Err(Error::UnintelligibleReply {
reply: Box::new(msg),
why: "The camera did not accept the stream start command.",
});
}
let mut media_sub = BinarySubscriber::from_bc_sub(&sub_video);
let mut result = Ok(());
while !abort_handle.load(Ordering::Relaxed) {
let bc_media = BcMedia::deserialize(&mut media_sub)?;
// We now have a complete interesting packet. Send it to on the callback
match data_outs.stream_recv(bc_media) {
Ok(true) => {}
Ok(false) => {
result = Ok(());
break;
}
Err(e) => {
result = Err(e);
break;
}
// On an E1 and swann cameras:
// - mainStream always has a value of 0
// - subStream always has a value of 1
// - There is no externStram
// On a B800:
// - mainStream is 0
// - subStream is 0
// - externStream is 0
let stream_code = match stream {
Stream::Main => 0,
Stream::Sub => 1,
Stream::Extern => 0,
};
}
// Aborted
println!("Stopping video: {:?}", result);
self.stop_video(stream)?;
println!("Video stopped");
result
// Theses are the numbers used with the offical client
// On an E1 and swann cameras:
// - mainStream always has a value of 0
// - subStream always has a value of 1
// - There is no externStram
// On a B800:
// - mainStream is 0
// - subStream is 256
// - externStram is 1024
let handle = match stream {
Stream::Main => 0,
Stream::Sub => 256,
Stream::Extern => 1024,
};
let stream_name = match stream {
Stream::Main => "mainStream",
Stream::Sub => "subStream",
Stream::Extern => "externStream",
}
.to_string();
let start_video = Bc::new_from_xml(
BcMeta {
msg_id: MSG_ID_VIDEO,
channel_id,
msg_num,
stream_type: stream_code,
response_code: 0,
class: 0x6414, // IDK why
},
BcXml {
preview: Some(Preview {
version: xml_ver(),
channel_id,
handle,
stream_type: Some(stream_name),
}),
..Default::default()
},
);
sub_video.send(start_video)?;
let msg = sub_video.rx.recv_timeout(RX_TIMEOUT)?;
if let BcMeta {
response_code: 200, ..
} = msg.meta
{
} else {
return Err(Error::UnintelligibleReply {
reply: Box::new(msg),
why: "The camera did not accept the stream start command.",
});
}
let mut media_sub = BinarySubscriber::from_bc_sub(&sub_video);
while !abort_handle_thread.load(Ordering::Relaxed) {
let bc_media = BcMedia::deserialize(&mut media_sub).map_err(Error::from);
// We now have a complete interesting packet. Send it to on the callback
if tx.send(bc_media).is_err() {
break; // Connection dropped
}
}
Ok(())
});
Ok(StreamData {
camera: self,
handle: Some(handle),
rx,
stream,
abort_handle,
})
}
/// Stop a camera from sending more stream data.
pub fn stop_video(&self, stream: Stream) -> Result<()> {
let connection = self
.connection
.as_ref()
.expect("Must be connected to stop video");
let connection = self.get_connection();
let msg_num = self.new_message_num();
let sub_video = connection.subscribe(msg_num)?;
+5 -8
View File
@@ -1,7 +1,7 @@
use super::{BcCamera, Error, Result, RX_TIMEOUT};
use crate::{bc::model::*, bc::xml::*, bcmedia::model::*};
use crossbeam_channel::Receiver;
use std::io::{BufRead, Error as IoError, ErrorKind, Read};
use std::sync::mpsc::Receiver;
type IoResult<T> = std::result::Result<T, IoError>;
@@ -14,7 +14,7 @@ impl BcCamera {
/// It is also sent when the request for talk config returns status code 422
///
pub fn talk_stop(&self) -> Result<()> {
let connection = self.connection.as_ref().expect("Must be connected");
let connection = self.get_connection();
let msg_num = self.new_message_num();
let sub = connection.subscribe(msg_num)?;
@@ -58,10 +58,7 @@ impl BcCamera {
/// Requests the [`TalkAbility`] xml
///
pub fn talk_ability(&self) -> Result<TalkAbility> {
let connection = self
.connection
.as_ref()
.expect("Must be connected to get time");
let connection = self.get_connection();
let msg_num = self.new_message_num();
let sub_get = connection.subscribe(msg_num)?;
let get = Bc {
@@ -120,7 +117,7 @@ impl BcCamera {
///
///
pub fn talk(&self, adpcm: &[u8], talk_config: TalkConfig) -> Result<()> {
let connection = self.connection.as_ref().expect("Must be connected");
let connection = self.get_connection();
let msg_num = self.new_message_num();
let sub = connection.subscribe(msg_num)?;
@@ -261,7 +258,7 @@ impl BcCamera {
///
///
pub fn talk_stream(&self, rx: Receiver<Vec<u8>>, talk_config: TalkConfig) -> Result<()> {
let connection = self.connection.as_ref().expect("Must be connected");
let connection = self.get_connection();
let msg_num = self.new_message_num();
let sub = connection.subscribe(msg_num)?;
+2 -8
View File
@@ -11,10 +11,7 @@ impl BcCamera {
/// returns either an error or an option with the offsetted date time
///
pub fn get_time(&self) -> Result<Option<OffsetDateTime>> {
let connection = self
.connection
.as_ref()
.expect("Must be connected to get time");
let connection = self.get_connection();
let msg_num = self.new_message_num();
let sub_get_general = connection.subscribe(msg_num)?;
let get = Bc {
@@ -98,10 +95,7 @@ impl BcCamera {
/// returns Ok(()) or error
///
pub fn set_time(&self, timestamp: OffsetDateTime) -> Result<()> {
let connection = self
.connection
.as_ref()
.expect("Must be connected to set time");
let connection = self.get_connection();
let msg_num = self.new_message_num();
let sub_set_general = connection.subscribe(msg_num)?;
let set = Bc::new_from_xml(
+1 -4
View File
@@ -4,10 +4,7 @@ use crate::bc::{model::*, xml::*};
impl BcCamera {
/// Request the [VersionInfo] xml
pub fn version(&self) -> Result<VersionInfo> {
let connection = self
.connection
.as_ref()
.expect("Must be connected to get version info");
let connection = self.get_connection();
let msg_num = self.new_message_num();
let sub_version = connection.subscribe(msg_num)?;
-7
View File
@@ -2,7 +2,6 @@ use lazy_static::lazy_static;
use regex::Regex;
use serde::Deserialize;
use std::clone::Clone;
use std::time::Duration;
use validator::{Validate, ValidationError};
use validator_derive::Validate;
@@ -55,12 +54,6 @@ pub(crate) struct CameraConfig {
pub(crate) username: String,
pub(crate) password: Option<String>,
// no longer used, but still here so we can warn users:
pub(crate) timeout: Option<Duration>,
// no longer used, but still here so we can warn users:
pub(crate) format: Option<String>,
#[validate(regex(
path = "RE_STREAM_SRC",
message = "Incorrect stream source",
+34 -34
View File
@@ -4,9 +4,7 @@ use crate::utils::AddressOrUid;
use anyhow::{anyhow, Context, Result};
use crossbeam_channel::{unbounded, Receiver, Sender, TryRecvError};
use log::*;
use neolink_core::bc_protocol::{
BcCamera, Error as BcError, LightState, MotionOutput, MotionOutputError, MotionStatus,
};
use neolink_core::bc_protocol::{BcCamera, Error as BcError, LightState, MotionStatus};
use std::sync::{Arc, Mutex};
pub(crate) enum Messages {
@@ -106,7 +104,7 @@ impl<'a> EventCam<'a> {
"{}: Connecting to camera at {}",
camera_config.name, camera_addr
);
let mut camera = camera_addr
let camera = camera_addr
.connect_camera(camera_config.channel_id)
.with_context(|| {
format!(
@@ -125,27 +123,27 @@ impl<'a> EventCam<'a> {
// Shararble cameras
let arc_cam = Arc::new(camera);
let cam_motion = arc_cam.clone();
let cam_mesg = arc_cam;
let mut motion_callback = MotionCallback {
let mut motion_thread = MotionThread {
app: app.clone(),
tx,
camera: arc_cam.clone(),
name: camera_config.name.to_string(),
};
let mut message_handler = MessageHandler {
app: app.clone(),
rx,
camera: cam_mesg,
camera: arc_cam,
name: camera_config.name.to_string(),
};
let _ = crossbeam::scope(|s| {
info!("{}: Listening to Camera Motion", camera_config.name);
s.spawn(|_| {
let _ = cam_motion.listen_on_motion(&mut motion_callback);
// If listen_on_motion returns then camera disconnect
if let Err(e) = motion_thread.run() {
error!("Motion thread aborted: {:?}", e);
}
app.abort(&camera_config.name);
});
@@ -159,38 +157,40 @@ impl<'a> EventCam<'a> {
}
}
struct MotionCallback {
struct MotionThread {
app: Arc<App>,
tx: Arc<Mutex<Sender<Messages>>>,
camera: Arc<BcCamera>,
name: String,
}
impl MotionOutput for MotionCallback {
fn motion_recv(&mut self, motion_status: MotionStatus) -> MotionOutputError {
if self.app.running(&format!("app:{}", self.name)) {
match motion_status {
MotionStatus::Start => {
(self
.tx
.lock()
.map_err(|_| BcError::Other("Failed to lock mutex"))?)
.send(Messages::MotionStart)
.map_err(|_| BcError::Other("Failed to send Message"))?;
impl MotionThread {
fn run(&mut self) -> Result<()> {
let mut motion_data = self.camera.listen_on_motion()?;
while self.app.running(&format!("app:{}", self.name)) {
for motion_status in motion_data.consume_motion_events()?.drain(..) {
match motion_status {
MotionStatus::Start(_) => {
(self
.tx
.lock()
.map_err(|_| BcError::Other("Failed to lock mutex"))?)
.send(Messages::MotionStart)
.map_err(|_| BcError::Other("Failed to send Message"))?;
}
MotionStatus::Stop(_) => {
(self
.tx
.lock()
.map_err(|_| BcError::Other("Failed to lock mutex"))?)
.send(Messages::MotionStop)
.map_err(|_| BcError::Other("Failed to send Message"))?;
}
_ => {}
}
MotionStatus::Stop => {
(self
.tx
.lock()
.map_err(|_| BcError::Other("Failed to lock mutex"))?)
.send(Messages::MotionStop)
.map_err(|_| BcError::Other("Failed to send Message"))?;
}
_ => {}
}
Ok(true)
} else {
Ok(false)
}
Ok(())
}
}
+5 -1
View File
@@ -3,7 +3,7 @@ use std::sync::{
Arc,
};
#[derive(Clone)]
#[derive(Clone, Default)]
pub(crate) struct AbortHandle {
live: Arc<AtomicBool>,
}
@@ -19,6 +19,10 @@ impl AbortHandle {
self.live.store(false, Ordering::Relaxed);
}
pub(crate) fn reset(&self) {
self.live.store(true, Ordering::Relaxed);
}
pub(crate) fn is_live(&self) -> bool {
self.live.load(Ordering::Relaxed)
}
+83 -81
View File
@@ -6,14 +6,13 @@ mod maybe_inputselect;
pub(crate) use self::maybe_app_src::MaybeAppSrc;
pub(crate) use self::maybe_inputselect::MaybeInputSelect;
use super::state::States;
// use super::adpcm::adpcm_to_pcm;
// use super::errors::Error;
use gstreamer::prelude::Cast;
use gstreamer::{Bin, Structure};
use gstreamer_app::AppSrc;
//use gstreamer_rtsp::RTSPLowerTrans;
use anyhow::anyhow;
use anyhow::{anyhow, Context};
use gstreamer_rtsp::RTSPAuthMethod;
pub use gstreamer_rtsp_server::gio::{TlsAuthenticationMode, TlsCertificate};
use gstreamer_rtsp_server::glib;
@@ -24,10 +23,7 @@ use gstreamer_rtsp_server::{
RTSP_TOKEN_MEDIA_FACTORY_ROLE,
};
use log::*;
use neolink_core::{
bc_protocol::{Error, StreamOutput, StreamOutputError},
bcmedia::model::*,
};
use neolink_core::bcmedia::model::*;
use std::collections::HashSet;
use std::fs;
use std::io;
@@ -38,15 +34,16 @@ type AnyResult<T> = std::result::Result<T, anyhow::Error>;
pub(crate) struct RtspServer {
server: GstRTSPServer,
main_loop: glib::MainLoop,
}
#[derive(Eq, PartialEq, Debug)]
#[derive(Eq, PartialEq, Debug, Copy, Clone)]
pub(crate) enum InputMode {
Live,
Paused,
}
#[derive(Eq, PartialEq, Debug)]
#[derive(Eq, PartialEq, Debug, Copy, Clone)]
pub(crate) enum PausedSources {
TestSrc,
Still,
@@ -62,7 +59,6 @@ pub(crate) struct GstOutputs {
video_format: Option<StreamFormat>,
audio_format: Option<StreamFormat>,
factory: RTSPMediaFactory,
state: Option<States>,
when_paused: PausedSources,
last_iframe: Option<Vec<u8>>,
}
@@ -83,63 +79,6 @@ enum StreamFormat {
Adpcm(u16),
}
impl StreamOutput for GstOutputs {
fn stream_recv(&mut self, media: BcMedia) -> StreamOutputError {
let mut should_continue = true;
// Ensure stream is on cam mode
self.set_input_source(InputMode::Live).map_err(|e| {
Error::OtherString(format!("Cannot set stream input to camera source {:?}", e))
})?;
match media {
BcMedia::Iframe(payload) => {
let video_type = match payload.video_type {
VideoType::H264 => StreamFormat::H264,
VideoType::H265 => StreamFormat::H265,
};
self.set_format(Some(video_type));
self.vidsrc.write_all(&payload.data).map_err(|e| {
Error::OtherString(format!("Cannot write IFrame to vidsrc {:?}", e))
})?;
self.last_iframe = Some(payload.data);
// Only stop on an iframe so we have the
// last frame to show
if let Some(state) = self.state.as_ref() {
should_continue = state.should_stream()
}
}
BcMedia::Pframe(payload) => {
let video_type = match payload.video_type {
VideoType::H264 => StreamFormat::H264,
VideoType::H265 => StreamFormat::H265,
};
self.set_format(Some(video_type));
self.vidsrc.write_all(&payload.data).map_err(|e| {
Error::OtherString(format!("Cannot write PFrame to vidsrc {:?}", e))
})?;
}
BcMedia::Aac(payload) => {
self.set_format(Some(StreamFormat::Aac));
self.audsrc.write_all(&payload.data).map_err(|e| {
Error::OtherString(format!("Cannot write AAC to audsrc {:?}", e))
})?;
}
BcMedia::Adpcm(payload) => {
self.set_format(Some(StreamFormat::Adpcm(payload.data.len() as u16)));
self.audsrc.write_all(&payload.data).map_err(|e| {
Error::OtherString(format!("Cannot write ADPCM to audsrc {:?}", e))
})?;
}
_ => {
//Ignore other BcMedia like InfoV1 and InfoV2
}
}
Ok(should_continue)
}
}
impl GstOutputs {
pub(crate) fn from_appsrcs(
vidsrc: MaybeAppSrc,
@@ -157,15 +96,53 @@ impl GstOutputs {
when_paused: PausedSources::None,
factory: RTSPMediaFactory::new(),
last_iframe: Default::default(),
state: Default::default(),
};
result.apply_format();
result
}
pub(crate) fn set_state(&mut self, state: States) {
self.vidsrc.state = Some(state.clone());
self.state = Some(state)
pub(crate) fn stream_recv(&mut self, media: BcMedia) -> AnyResult<()> {
// Ensure stream is on cam mode
match media {
BcMedia::Iframe(payload) => {
let video_type = match payload.video_type {
VideoType::H264 => StreamFormat::H264,
VideoType::H265 => StreamFormat::H265,
};
self.set_format(Some(video_type));
self.vidsrc
.write_all(&payload.data)
.with_context(|| "Cannot write IFrame to vidsrc")?;
self.last_iframe = Some(payload.data);
}
BcMedia::Pframe(payload) => {
let video_type = match payload.video_type {
VideoType::H264 => StreamFormat::H264,
VideoType::H265 => StreamFormat::H265,
};
self.set_format(Some(video_type));
self.vidsrc
.write_all(&payload.data)
.with_context(|| "Cannot write PFrame to vidsrc")?;
}
BcMedia::Aac(payload) => {
self.set_format(Some(StreamFormat::Aac));
self.audsrc
.write_all(&payload.data)
.with_context(|| "Cannot write AAC to audsrc")?;
}
BcMedia::Adpcm(payload) => {
self.set_format(Some(StreamFormat::Adpcm(payload.data.len() as u16)));
self.audsrc
.write_all(&payload.data)
.with_context(|| "Cannot write ADPCM to audsrc")?;
}
_ => {
//Ignore other BcMedia like InfoV1 and InfoV2
}
}
Ok(())
}
pub(crate) fn set_input_source(&mut self, input_source: InputMode) -> AnyResult<()> {
@@ -359,6 +336,10 @@ impl GstOutputs {
debug!("Gstreamer launch str: {:?}", launch_str);
self.factory.set_launch(launch_str);
}
pub(crate) fn is_connected(&self) -> bool {
self.vidsrc.is_connected() || self.audsrc.is_connected()
}
}
impl Default for RtspServer {
@@ -372,13 +353,14 @@ impl RtspServer {
gstreamer::init().expect("Gstreamer should not explode");
RtspServer {
server: GstRTSPServer::new(),
main_loop: glib::MainLoop::new(None, false),
}
}
pub(crate) fn add_stream(
pub(crate) fn add_stream<T: AsRef<str>>(
&self,
paths: &[&str],
permitted_users: &HashSet<&str>,
permitted_users: &HashSet<T>,
) -> Result<GstOutputs> {
let mounts = self
.server
@@ -407,7 +389,7 @@ impl RtspServer {
debug!(
"Permitting {} to access {}",
// This is hashmap or (iter) equivalent of join, it requres itertools
itertools::Itertools::intersperse(permitted_users.iter().cloned(), ", ")
itertools::Itertools::intersperse(permitted_users.iter().map(|i| i.as_ref()), ", ")
.collect::<String>(),
paths.join(", ")
);
@@ -424,14 +406,14 @@ impl RtspServer {
.expect("Media source's element should be a bin");
let app_src = bin
.by_name_recurse_up("vidsrc")
.expect("write_src must be present in created bin")
.expect("vidsrc must be present in created bin")
.dynamic_cast::<AppSrc>()
.expect("Source element is expected to be an appsrc!");
let _ = tx.send(app_src); // Receiver may be dropped, don't panic if so
let app_src_aud = bin
.by_name_recurse_up("audsrc")
.expect("write_src must be present in created bin")
.expect("audsrc must be present in created bin")
.dynamic_cast::<AppSrc>()
.expect("Source element is expected to be an appsrc!");
let _ = tx_aud.send(app_src_aud); // Receiver may be dropped, don't panic if so
@@ -454,14 +436,25 @@ impl RtspServer {
Ok(outputs)
}
pub(crate) fn add_permitted_roles(
pub(crate) fn remove_stream(&self, paths: &[&str]) -> Result<()> {
let mounts = self
.server
.mount_points()
.expect("The server should have mountpoints");
for path in paths {
mounts.remove_factory(path);
}
Ok(())
}
pub(crate) fn add_permitted_roles<T: AsRef<str>>(
&self,
factory: &RTSPMediaFactory,
permitted_roles: &HashSet<&str>,
permitted_roles: &HashSet<T>,
) {
for permitted_role in permitted_roles {
factory.add_role_from_structure(&Structure::new(
permitted_role,
permitted_role.as_ref(),
&[
(*RTSP_PERM_MEDIA_FACTORY_ACCESS, &true),
(*RTSP_PERM_MEDIA_FACTORY_CONSTRUCT, &true),
@@ -482,7 +475,12 @@ impl RtspServer {
// FYI: If no RTSP_PERM_MEDIA_FACTORY_ACCESS then server returns 404 not found
// If yes RTSP_PERM_MEDIA_FACTORY_ACCESS but no RTSP_PERM_MEDIA_FACTORY_CONSTRUCT
// server returns 401 not authourised
if !permitted_roles.contains(&"anonymous") {
if !permitted_roles
.iter()
.map(|i| i.as_ref())
.collect::<HashSet<&str>>()
.contains(&"anonymous")
{
factory.add_role_from_structure(&Structure::new(
"anonymous",
&[(*RTSP_PERM_MEDIA_FACTORY_ACCESS, &true)],
@@ -534,7 +532,11 @@ impl RtspServer {
let _ = self.server.attach(None);
// Run the Glib main loop.
let main_loop = glib::MainLoop::new(None, false);
main_loop.run();
self.main_loop.run();
}
#[allow(dead_code)]
pub(crate) fn quit(&self) {
self.main_loop.quit();
}
}
+16 -20
View File
@@ -1,32 +1,24 @@
use super::*;
use std::sync::mpsc::{sync_channel, Receiver, SyncSender};
use crossbeam_channel::{bounded, Receiver, Sender};
/// A Write implementation around AppSrc that also allows delaying the creation of the AppSrc
/// until later, discarding written data until the AppSrc is provided.
pub(crate) struct MaybeAppSrc {
rx: Receiver<AppSrc>,
app_src: Option<AppSrc>,
pub(super) state: Option<States>,
}
impl MaybeAppSrc {
/// Creates a MaybeAppSrc. Also returns a Sender that you must use to provide an AppSrc as
/// soon as one is available. When it is received, the MaybeAppSrc will start pushing data
/// into the AppSrc when write() is called.
pub(crate) fn new_with_tx() -> (Self, SyncSender<AppSrc>) {
let (tx, rx) = sync_channel(3); // The sender should not send very often
(
MaybeAppSrc {
rx,
app_src: None,
state: Default::default(),
},
tx,
)
pub(crate) fn new_with_tx() -> (Self, Sender<AppSrc>) {
let (tx, rx) = bounded(3); // The sender should not send very often
(MaybeAppSrc { rx, app_src: None }, tx)
}
/// Flushes data to Gstreamer on a problem communicating with the underlying video source.
pub(crate) fn on_stream_error(&mut self) {
/// Calls end of stream to Gstreamer, using during drop
pub(crate) fn end_of_stream(&mut self) {
if let Some(src) = self.try_get_src() {
// Ignore "errors" from Gstreamer such as FLUSHING, which are not really errors.
let _ = src.end_of_stream();
@@ -40,12 +32,13 @@ impl MaybeAppSrc {
fn try_get_src(&mut self) -> Option<&AppSrc> {
while let Ok(src) = self.rx.try_recv() {
self.app_src = Some(src);
if let Some(state) = self.state.as_ref() {
state.set_client_connected(true);
}
}
self.app_src.as_ref()
}
pub(crate) fn is_connected(&self) -> bool {
self.app_src.is_some()
}
}
impl Write for MaybeAppSrc {
@@ -66,9 +59,6 @@ impl Write for MaybeAppSrc {
let res = app_src.push_buffer(gst_buf); //.map_err(|e| io::Error::new(io::ErrorKind::Other, Box::new(e)))?;
if res.is_err() {
self.app_src = None;
if let Some(state) = self.state.as_ref() {
state.set_client_connected(false);
}
}
Ok(buf.len())
}
@@ -77,3 +67,9 @@ impl Write for MaybeAppSrc {
Ok(())
}
}
impl Drop for MaybeAppSrc {
fn drop(&mut self) {
self.end_of_stream();
}
}
+3 -3
View File
@@ -1,9 +1,9 @@
use anyhow::{anyhow, Error as Anyhow};
use crossbeam_channel::{bounded, Receiver, Sender};
use gstreamer::prelude::ElementExt;
use gstreamer::prelude::ObjectExt;
use gstreamer::{Element, Pad};
use log::*;
use std::sync::mpsc::{sync_channel, Receiver, SyncSender};
pub(crate) struct MaybeInputSelect {
rx: Receiver<Element>,
@@ -11,8 +11,8 @@ pub(crate) struct MaybeInputSelect {
}
impl MaybeInputSelect {
pub(crate) fn new_with_tx() -> (Self, SyncSender<Element>) {
let (tx, rx) = sync_channel(3); // The sender should not send very often
pub(crate) fn new_with_tx() -> (Self, Sender<Element>) {
let (tx, rx) = bounded(3); // The sender should not send very often
(MaybeInputSelect { rx, typefind: None }, tx)
}
+1 -1
View File
@@ -1,5 +1,5 @@
use gstreamer::Element;
use std::sync::mpsc::{sync_channel, Receiver, SyncSender};
use crossbeam_channel::{sync_channel, Receiver, SyncSender};
pub(crate) struct MaybeOutputSelect {
rx: Receiver<Element>,
+1 -1
View File
@@ -1,5 +1,5 @@
use gstreamer::Element;
use std::sync::mpsc::{sync_channel, Receiver, SyncSender};
use crossbeam_channel::{sync_channel, Receiver, SyncSender};
pub(crate) struct MaybeTypeFind {
rx: Receiver<Element>,
+164 -382
View File
@@ -28,145 +28,202 @@
/// neolink rtsp --config=config.toml
/// ```
///
use anyhow::{Context, Result};
use anyhow::{anyhow, Context, Result};
use crossbeam::utils::Backoff;
use log::*;
use neolink_core::bc_protocol::{BcCamera, Stream};
use std::collections::HashSet;
use std::sync::{
atomic::{AtomicBool, Ordering},
Arc, Mutex,
};
use std::sync::Arc;
use std::time::Duration;
mod abort;
mod cmdline;
mod gst;
mod motion;
mod state;
mod states;
use abort::AbortHandle;
use states::{RtspCamera, StateInfo};
use super::config::{CameraConfig, Config, UserConfig};
use crate::utils::AddressOrUid;
pub(crate) use cmdline::Opt;
use gst::{GstOutputs, InputMode, PausedSources, RtspServer, TlsAuthenticationMode};
use motion::MotionStream;
use state::States;
use gst::{RtspServer, TlsAuthenticationMode};
/// Entry point for the rtsp subcommand
///
/// Opt is the command line options
pub(crate) fn main(_opt: Opt, config: Config) -> Result<()> {
let rtsp = &RtspServer::new();
pub(crate) fn main(_opt: Opt, mut config: Config) -> Result<()> {
let rtsp = Arc::new(RtspServer::new());
set_up_tls(&config, rtsp);
set_up_tls(&config, &rtsp);
set_up_users(&config.users, rtsp);
set_up_users(&config.users, &rtsp);
if config.certificate.is_none() && !config.users.is_empty() {
warn!(
"Without a server certificate, usernames and passwords will be exchanged in plaintext!"
)
}
crossbeam::scope(|s| {
for camera in config.cameras {
if camera.format.is_some() {
warn!("The format config option of the camera has been removed in favour of auto detection.")
}
// Let subthreads share the camera object; in principle I think they could share
// the object as it sits in the config.cameras block, but I have not figured out the
// syntax for that.
let arc_cam = Arc::new(camera);
let abort = AbortHandle::new();
let permitted_users =
get_permitted_users(config.users.as_slice(), &arc_cam.permitted_users);
let arc_user_config = Arc::new(config.users);
for camera_config in config.cameras.drain(..) {
// Spawn each camera controller in it's own thread
let user_config = arc_user_config.clone();
let arc_rtsp = rtsp.clone();
let abort_handle = abort.clone();
s.spawn(move |_| {
let backoff = Backoff::new();
let mut stream_outputs: Vec<(Stream, Arc<Mutex<GstOutputs>>)> = vec![];
// Set up each main and substream according to all the RTSP mount paths we support
if ["all", "both", "mainStream"].iter().any(|&e| e == arc_cam.stream) {
let paths = &[
&*format!("/{}", arc_cam.name),
&*format!("/{}/mainStream", arc_cam.name),
];
let outputs = rtsp
.add_stream(paths, &permitted_users)
.unwrap();
stream_outputs.push((Stream::Main, Arc::new(Mutex::new(outputs))));
}
if ["all", "both", "subStream"].iter().any(|&e| e == arc_cam.stream) {
let paths = &[&*format!("/{}/subStream", arc_cam.name)];
let outputs = rtsp
.add_stream(paths, &permitted_users)
.unwrap();
stream_outputs.push((Stream::Sub, Arc::new(Mutex::new(outputs))));
}
if ["all", "externStream"].iter().any(|&e| e == arc_cam.stream) {
let paths = &[&*format!("/{}/externStream", arc_cam.name)];
let outputs = rtsp
.add_stream(paths, &permitted_users)
.unwrap();
stream_outputs.push((Stream::Extern, Arc::new(Mutex::new(outputs))));
}
let main_camera = arc_cam.clone();
s.spawn(move |_| camera_loop(&main_camera, stream_outputs, true));
while abort_handle.is_live() {
let failure =
camera_main(&camera_config, user_config.as_slice(), arc_rtsp.clone());
match failure {
Err(CameraFailureKind::Fatal(e)) => {
error!("{}: Fatal error: {:?}", camera_config.name, e);
break;
}
Err(CameraFailureKind::Retry(e)) => {
warn!("{}: Retryable error: {:?}", camera_config.name, e);
backoff.spin();
}
Ok(()) => {
info!("{}: Shutting down", camera_config.name);
break;
}
}
}
});
}
info!(
"Starting RTSP Server at {}:{}",
&config.bind_addr, config.bind_port,
);
rtsp.run(&config.bind_addr, config.bind_port);
})
.unwrap();
.map_err(|e| anyhow::anyhow!("Thread panicked: {:?}", e))?;
Ok(())
}
fn camera_loop(
camera_config: &CameraConfig,
end_points: Vec<(Stream, Arc<Mutex<GstOutputs>>)>,
manage: bool,
) -> Result<(), anyhow::Error> {
let min_backoff = Duration::from_secs(1);
let max_backoff = Duration::from_secs(15);
let mut current_backoff = min_backoff;
loop {
if let Err(cam_err) = camera_main(camera_config, &end_points, manage) {
for (_, outputs) in end_points.iter() {
(outputs.lock().unwrap()).vidsrc.on_stream_error();
(outputs.lock().unwrap()).audsrc.on_stream_error();
}
// Authentication failures are permanent; we retry everything else
if cam_err.connected {
current_backoff = min_backoff;
}
if cam_err.login_fail {
error!(
"Authentication failed to camera {}, not retrying",
camera_config.name
);
return Err(cam_err.err);
} else {
error!(
"Error streaming from camera {}, will retry in {}s: {:?}",
camera_config.name,
current_backoff.as_secs(),
cam_err.err
)
}
std::thread::sleep(current_backoff);
current_backoff = std::cmp::min(max_backoff, current_backoff * 2);
} else {
// Should not occur because we don't set the callback up
// in such a way that it requests graceful shutdown
return Ok(());
}
}
enum CameraFailureKind {
Fatal(anyhow::Error),
Retry(anyhow::Error),
}
struct CameraErr {
connected: bool,
login_fail: bool,
err: anyhow::Error,
fn camera_main(
config: &CameraConfig,
user_config: &[UserConfig],
rtsp: Arc<RtspServer>,
) -> Result<(), CameraFailureKind> {
// Connect
let mut camera = RtspCamera::new(config, user_config, rtsp)
.with_context(|| format!("{}: Could not connect camera", config.name))
.map_err(CameraFailureKind::Retry)?;
camera
.login()
.with_context(|| format!("{}: Could not login to camera", config.name))
.map_err(CameraFailureKind::Fatal)?;
let _ = camera.manage();
camera
.stream()
.with_context(|| format!("{}: Could not start stream", config.name))
.map_err(CameraFailureKind::Retry)?;
let backoff = Backoff::new();
let mut motion = if config.pause.on_motion {
Some(
camera
.motion_data()
.with_context(|| {
"Could not initialise motion detection. Is it supported with this camera?"
})
.map_err(CameraFailureKind::Retry)?,
)
} else {
None
};
let motion_timeout: Duration = Duration::from_secs_f64(config.pause.motion_timeout);
loop {
match camera.get_state() {
StateInfo::Streaming => {
let can_pause = camera.can_pause();
if config.pause.on_disconnect {
if let Some(false) = camera.client_connected() {
if can_pause {
info!("Pause on disconnect");
camera.pause().map_err(CameraFailureKind::Retry)?;
} else {
warn!("Not ready to pause");
}
}
}
if config.pause.on_motion {
if let Some(motion) = motion.as_mut() {
match motion
.motion_detected_within(motion_timeout)
.with_context(|| "Motion detection unexpectedly stopped")
.map_err(CameraFailureKind::Retry)?
{
Some(false) => {
if can_pause {
info!("Pause on motion");
camera.pause().map_err(CameraFailureKind::Retry)?;
} else {
warn!("Not ready to pause");
}
}
None => {
if can_pause {
info!("Pause on motion (start)");
camera.pause().map_err(CameraFailureKind::Retry)?;
} else {
warn!("Not ready to pause");
}
}
_ => {}
}
}
}
if !camera.is_running() {
return Err(CameraFailureKind::Retry(anyhow!(
"Camera has unexpectanely stopped the paused state"
)));
}
}
StateInfo::Paused => {
if config.pause.on_disconnect {
if let Some(true) = camera.client_connected() {
info!("Resume on disconnect");
camera.stream().map_err(CameraFailureKind::Retry)?;
}
}
if config.pause.on_motion {
if let Some(motion) = motion.as_mut() {
if let Some(true) = motion
.motion_detected_within(motion_timeout)
.with_context(|| "Motion detection unexpectedly stopped")
.map_err(CameraFailureKind::Retry)?
{
info!("Resume on motion");
camera.stream().map_err(CameraFailureKind::Retry)?;
}
}
}
if !camera.is_running() {
return Err(CameraFailureKind::Retry(anyhow!(
"Camera has unexpectanely stopped the paused state"
)));
}
}
_ => {
return Err(CameraFailureKind::Retry(anyhow!(
"Camera has unexpectanely stopped the paused state"
)));
}
}
backoff.spin();
}
}
fn set_up_tls(config: &Config, rtsp: &RtspServer) {
@@ -191,278 +248,3 @@ fn set_up_users(users: &[UserConfig], rtsp: &RtspServer) {
rtsp.set_credentials(&credentials)
.expect("Failed to set up users");
}
fn get_permitted_users<'a>(
users: &'a [UserConfig],
// not idiomatic as a function argument, but this fn translates the config struct directly:
permitted_users: &'a Option<Vec<String>>,
) -> HashSet<&'a str> {
// Helper to build hashset of all users in `users`:
let all_users_hash = || users.iter().map(|u| u.name.as_str()).collect();
match permitted_users {
// If in the camera config there is the user "anyone", or if none is specified but users
// are defined at all, then we add all users to the camera's allowed list.
Some(p) if p.iter().any(|u| u == "anyone") => all_users_hash(),
None if !users.is_empty() => all_users_hash(),
// The user specified permitted_users
Some(p) => p.iter().map(String::as_str).collect(),
// The user didn't specify permitted_users, and there are none defined anyway
None => ["anonymous"].iter().cloned().collect(),
}
}
fn camera_main(
camera_config: &CameraConfig,
end_points: &[(Stream, Arc<Mutex<GstOutputs>>)],
manage: bool,
) -> Result<(), CameraErr> {
let mut connected = false;
let mut login_fail = false;
(|| -> Result<(), anyhow::Error> {
let camera_addr =
AddressOrUid::new(&camera_config.camera_addr, &camera_config.camera_uid).unwrap();
let mut camera =
camera_addr.connect_camera(camera_config.channel_id)
.with_context(|| {
format!(
"Failed to connect to camera {} at {} on channel {}",
camera_config.name, camera_addr, camera_config.channel_id
)
})?;
if camera_config.timeout.is_some() {
warn!("The undocumented `timeout` config option has been removed and is no longer needed.");
warn!("Please update your config file.");
}
info!(
"{}: Connecting to camera at {}",
camera_config.name, camera_addr
);
info!("{}: Logging in", camera_config.name);
camera.login(&camera_config.username, camera_config.password.as_deref()).map_err(|e|
{
if let neolink_core::Error::AuthFailed = e {
login_fail = true;
}
e
}
).with_context(|| format!("Failed to login to {}", camera_config.name))?;
connected = true;
info!("{}: Connected and logged in", camera_config.name);
if manage {
do_camera_management(&mut camera, camera_config).context("Failed to manage the camera settings")?;
}
let arc_camera_results: Arc<Mutex<Vec<Result<(), anyhow::Error>>>> = Default::default();
let arc_camera = Arc::new(camera);
crossbeam::scope(|s| {
let arc_abort_handle = Arc::new(AtomicBool::new(false));
for (stream_name, arc_outputs) in end_points.iter() {
let stream_display_name = match stream_name {
Stream::Main => "Main Stream (Clear)",
Stream::Sub => "Sub Stream (Fluent)",
Stream::Extern => "Extern Stream (Balanced)",
};
info!(
"{}: Starting video stream {}",
camera_config.name, stream_display_name
);
let camera_results = arc_camera_results.clone();
let camera = arc_camera.clone();
let outputs = arc_outputs.clone();
let abort_handle = arc_abort_handle.clone();
let abort_handle_2 = arc_abort_handle.clone();
s.spawn(move |_| {
let camera_result = pausable_camera(camera_config, &camera, &mut outputs.lock().unwrap(), *stream_name, abort_handle).with_context(|| format!("Error while streaming {}", camera_config.name));
(*camera_results.lock().unwrap()).push(camera_result);
let _ = camera.stop_video(*stream_name);
abort_handle_2.store(true, Ordering::Relaxed);
});
}
}).unwrap();
let mut camera_results = arc_camera_results.lock().unwrap();
while camera_results.len() > 0 {
camera_results.pop().unwrap()?; // Need to take ownership
}
unreachable!(); // Should always error before this
})().map_err(|e| CameraErr{
connected,
login_fail,
err: e,
})
}
fn pausable_camera(
camera_config: &CameraConfig,
camera: &Arc<BcCamera>,
data_outs: &mut GstOutputs,
stream: Stream,
abort_handle: Arc<AtomicBool>,
) -> Result<()> {
if !camera_config.pause.on_motion && !camera_config.pause.on_disconnect {
// Stream is always on
camera
.start_video(data_outs, stream, abort_handle)
.with_context(|| format!("Error while streaming {}", camera_config.name))
} else {
let pause_config = &camera_config.pause;
// Used to get the error from the thread
let thread_error: Arc<Mutex<Option<anyhow::Error>>> = Default::default();
// Used to abort all sub threads if any of them request closure
// and control the motion/client state info
let state = States::new_from_camera_config(camera_config);
data_outs.set_state(state.clone());
let paused_source = match pause_config.mode.as_str() {
"test" => PausedSources::TestSrc,
"still" => PausedSources::Still,
"black" => PausedSources::Black,
"none" => PausedSources::None,
_ => {
unreachable!()
}
};
data_outs.set_paused_source(paused_source);
crossbeam::scope(|s| {
let mut motion = MotionStream::new(pause_config.motion_timeout, state.clone());
let arc_camera = Arc::new(camera);
// Motion detection thread
let motion_camera = arc_camera.clone();
let motion_camname = camera_config.name.to_string();
let motion_error = thread_error.clone();
let motion_state = state.clone();
s.spawn(move |_| {
if let Err(e) = motion_camera
.listen_on_motion(&mut motion)
.with_context(|| format!("Error while reading motion {}", motion_camname))
{
// When motion errors set the thread error
*motion_error.lock().unwrap() = Some(e);
}
// Always abort the streams/motion when motion stops regardless of why
// so that this thread can reset the camera
motion_state.abort();
debug!("Motion stopped");
});
// Stream thread
let stream_camera = arc_camera;
let stream_camname = camera_config.name.to_string();
let stream_error = thread_error.clone();
let stream_state = state.clone();
s.spawn(move |_| {
while stream_state.is_live() {
if stream_state.should_stream() || !data_outs.has_last_iframe() {
if let Err(e) = data_outs.set_input_source(InputMode::Live) {
*stream_error.lock().unwrap() = Some(e);
break;
}
debug!("Stream resumed");
// Will block until the rx thread send the abort
if let Err(e) = stream_camera
.start_video(data_outs, stream, abort_handle.clone())
.with_context(|| format!("Error while streaming {}", stream_camname))
{
error!("Stream error {:?}", e);
// When stream errors set the thread error and abort the motion
*stream_error.lock().unwrap() = Some(e);
break;
}
debug!("Stream paused");
} else {
if let Err(e) = data_outs.set_input_source(InputMode::Paused) {
*stream_error.lock().unwrap() = Some(e);
break;
}
// While stream is aborted we send the last iframe
if let Err(e) = data_outs.write_last_iframe().with_context(|| {
format!("Failed to write no motion image for {}", stream_camname)
}) {
*stream_error.lock().unwrap() = Some(e);
break;
}
std::thread::sleep(std::time::Duration::from_millis(50));
}
}
stream_state.abort();
debug!("Stream stopped");
});
})
.unwrap();
// Should be the only one holding the thread_error so unwrap it
// all the way to an actual error
Err(Arc::try_unwrap(thread_error)
.unwrap()
.into_inner()
.unwrap()
.unwrap())
}
}
fn do_camera_management(camera: &mut BcCamera, camera_config: &CameraConfig) -> Result<()> {
let cam_time = camera.get_time()?;
if let Some(time) = cam_time {
info!(
"{}: Camera time is already set: {}",
camera_config.name, time
);
} else {
use time::OffsetDateTime;
// We'd like now_local() but it's deprecated - try to get the local time, but if no
// time zone, fall back to UTC.
let new_time =
OffsetDateTime::try_now_local().unwrap_or_else(|_| OffsetDateTime::now_utc());
warn!(
"{}: Camera has no time set, setting to {}",
camera_config.name, new_time
);
camera.set_time(new_time)?;
let cam_time = camera.get_time()?;
if let Some(time) = cam_time {
info!("{}: Camera time is now set: {}", camera_config.name, time);
} else {
error!(
"{}: Camera did not accept new time (is {} an admin?)",
camera_config.name, camera_config.username
);
}
}
use neolink_core::bc::xml::VersionInfo;
if let Ok(VersionInfo {
firmwareVersion: firmware_version,
..
}) = camera.version()
{
info!(
"{}: Camera reports firmware version {}",
camera_config.name, firmware_version
);
} else {
info!(
"{}: Could not fetch version information",
camera_config.name
);
}
Ok(())
}
-53
View File
@@ -1,53 +0,0 @@
use super::abort::AbortHandle;
use super::state::States;
use neolink_core::bc_protocol::{MotionOutput, MotionOutputError, MotionStatus};
use std::time::Duration;
pub(crate) struct MotionStream {
state: States,
timeout: Duration,
cooloff: Option<AbortHandle>,
}
impl MotionStream {
pub(crate) fn new(timeout_seconds: f64, state: States) -> Self {
Self {
state,
timeout: Duration::from_secs_f64(timeout_seconds),
cooloff: None,
}
}
}
impl MotionOutput for MotionStream {
fn motion_recv(&mut self, motion_status: MotionStatus) -> MotionOutputError {
match motion_status {
MotionStatus::Start => {
if let Some(handle) = &self.cooloff {
handle.abort();
self.cooloff = None;
}
self.state.set_motion_detected(true);
}
MotionStatus::Stop => {
// Abort any current one
if let Some(handle) = &self.cooloff {
handle.abort();
self.cooloff = None;
}
let aborter = AbortHandle::new();
let thread_duration = self.timeout;
let thread_state = self.state.clone();
std::thread::spawn(move || {
std::thread::sleep(thread_duration);
if aborter.is_live() {
thread_state.set_motion_detected(false);
}
});
}
_ => {}
}
Ok(self.state.is_live())
}
}
-98
View File
@@ -1,98 +0,0 @@
//! Used to handle the stream states
//!
//! When should stream is true then neolink
//! pulls the video from the camera.
//!
//! Otherwise it should use a fallback image
//!
use super::CameraConfig;
use log::*;
use std::sync::{
atomic::{AtomicBool, Ordering},
Arc, Mutex,
};
enum MotionState {
Motion,
Still,
Ignore,
}
enum RtspState {
Connected,
Disconnected,
Ignore,
}
#[derive(Clone)]
pub(crate) struct States {
motion: Arc<Mutex<MotionState>>,
client: Arc<Mutex<RtspState>>,
live: Arc<AtomicBool>,
}
impl States {
pub(crate) fn new(motion_controlled: bool, client_controlled: bool) -> Self {
let motion = match motion_controlled {
true => MotionState::Still,
false => MotionState::Ignore,
};
let client = match client_controlled {
true => RtspState::Disconnected,
false => RtspState::Ignore,
};
Self {
motion: Arc::new(Mutex::new(motion)),
client: Arc::new(Mutex::new(client)),
live: Arc::new(AtomicBool::new(true)),
}
}
pub(crate) fn new_from_camera_config(camera_config: &CameraConfig) -> Self {
let motion_controlled = camera_config.pause.on_motion;
let client_controlled = camera_config.pause.on_disconnect;
Self::new(motion_controlled, client_controlled)
}
pub(crate) fn should_stream(&self) -> bool {
if let MotionState::Still = *self.motion.lock().unwrap() {
return false;
}
!matches!(*self.client.lock().unwrap(), RtspState::Disconnected)
}
pub(crate) fn set_client_connected(&self, value: bool) {
let mut client = self.client.lock().unwrap();
if let RtspState::Ignore = *client {
return;
}
debug!("Client state: {}", value);
*client = match value {
true => RtspState::Connected,
false => RtspState::Disconnected,
}
}
pub(crate) fn set_motion_detected(&self, value: bool) {
let mut motion = self.motion.lock().unwrap();
if let MotionState::Ignore = *motion {
return;
}
debug!("Motion state: {}", value);
*motion = match value {
true => MotionState::Motion,
false => MotionState::Still,
};
}
pub(crate) fn abort(&self) {
self.live.store(false, Ordering::Relaxed);
}
pub(crate) fn is_live(&self) -> bool {
self.live.load(Ordering::Relaxed)
}
}
+18
View File
@@ -0,0 +1,18 @@
// Data for the basic connected state
//
// This state has formed the TCP/UDP tunnel
// but has not logged in
use super::{CameraState, Shared};
use anyhow::{Error, Result};
#[derive(Default)]
pub(crate) struct Connected {}
impl CameraState for Connected {
fn setup(&mut self, _shared: &Shared) -> Result<(), Error> {
Ok(())
}
fn tear_down(&mut self, _shared: &Shared) -> Result<(), Error> {
Ok(())
}
}
+26
View File
@@ -0,0 +1,26 @@
// Data for the logged in state
//
// This state is logged in but is not
// streaming data
//
// It can be used to alter settings etc
use super::{CameraState, Shared};
use anyhow::Result;
#[derive(Default)]
pub(crate) struct LoggedIn {}
impl CameraState for LoggedIn {
fn setup(&mut self, shared: &Shared) -> Result<(), anyhow::Error> {
shared
.camera
.login(&shared.username, shared.password.as_deref())?;
Ok(())
}
fn tear_down(&mut self, shared: &Shared) -> Result<(), anyhow::Error> {
shared.camera.logout()?;
Ok(())
}
}
+314
View File
@@ -0,0 +1,314 @@
//! Handles the camera in it's different states
//!
use anyhow::{anyhow, Context, Error, Result};
use log::*;
use std::collections::HashSet;
use std::sync::Arc;
use neolink_core::bc_protocol::{MotionData, Stream};
use crate::config::{CameraConfig, UserConfig};
use crate::rtsp::gst::RtspServer;
use crate::utils::AddressOrUid;
mod connected;
mod loggedin;
mod paused;
mod shared;
mod streaming;
pub(crate) use connected::Connected;
pub(crate) use loggedin::LoggedIn;
pub(crate) use paused::Paused;
pub(crate) use shared::{CameraState, Shared};
pub(crate) use streaming::Streaming;
pub(crate) enum StateInfo {
Connected,
LoggedIn,
Streaming,
Paused,
}
enum State {
Connected(Connected),
LoggedIn(LoggedIn),
Streaming(Streaming),
Paused(Paused),
}
///
/// The state machine representation of the camera
///
pub(crate) struct RtspCamera {
shared: Shared,
state: State,
}
impl RtspCamera {
pub(crate) fn new(
config: &CameraConfig,
users: &[UserConfig],
rtsp: Arc<RtspServer>,
) -> Result<Self, Error> {
let camera_addr =
AddressOrUid::new(&config.camera_addr, &config.camera_uid).with_context(|| {
format!(
"Could not connect to camera {}. Please check UUID or IP:Port in the config",
config.name
)
})?;
info!("{}: Connecting to camera at {}", config.name, camera_addr);
let camera = camera_addr
.connect_camera(config.channel_id)
.with_context(|| {
format!(
"Failed to connect to camera {} at {} on channel {}",
config.name, camera_addr, config.channel_id
)
})?;
let mut streams: HashSet<Stream> = Default::default();
if ["all", "both", "mainStream", "mainstream"]
.iter()
.any(|&e| e == config.stream)
{
streams.insert(Stream::Main);
}
if ["all", "both", "subStream", "substream"]
.iter()
.any(|&e| e == config.stream)
{
streams.insert(Stream::Sub);
}
if ["both", "externStream", "externstream"]
.iter()
.any(|&e| e == config.stream)
{
streams.insert(Stream::Extern);
}
// Used to build the list of strings to pass to gtreamer for the allowed users
let all_users_hash = || users.iter().map(|u| u.name.clone()).collect();
let permitted_users = match &config.permitted_users {
// If in the camera config there is the user "anyone", or if none is specified but users
// are defined at all, then we add all users to the camera's allowed list.
Some(p) if p.iter().any(|u| u == "anyone") => all_users_hash(),
None if !users.is_empty() => all_users_hash(),
// The user specified permitted_users
Some(p) => p.iter().cloned().collect(),
// The user didn't specify permitted_users, and there are none defined anyway
None => ["anonymous".to_string()].iter().cloned().collect(),
};
let shared = Shared {
camera: Arc::new(camera),
addr: camera_addr,
name: config.name.clone(),
channel: config.channel_id,
username: config.username.clone(),
password: config.password.clone(),
pause: config.pause.clone(),
streams,
rtsp,
permitted_users,
};
let mut state: Connected = Default::default();
state.setup(&shared)?;
Ok(Self {
shared,
state: State::Connected(state),
})
}
pub(crate) fn get_state(&self) -> StateInfo {
match &self.state {
State::Connected(_) => StateInfo::Connected,
State::LoggedIn(_) => StateInfo::LoggedIn,
State::Streaming(_) => StateInfo::Streaming,
State::Paused(_) => StateInfo::Paused,
}
}
pub(crate) fn login(&mut self) -> Result<()> {
match &mut self.state {
State::Connected(ref mut connected) => {
info!("{}: Logging in", &self.shared.name);
connected.tear_down(&self.shared)?;
let mut state: LoggedIn = Default::default();
state.setup(&self.shared)?;
self.state = State::LoggedIn(state);
info!("{}: Successfully logged in", &self.shared.name);
}
State::Streaming(ref mut connected) => {
info!("{}: Logging in", &self.shared.name);
connected.tear_down(&self.shared)?;
let mut state: LoggedIn = Default::default();
state.setup(&self.shared)?;
self.state = State::LoggedIn(state);
info!("{}: Successfully stopped straming", &self.shared.name);
}
State::Paused(ref mut connected) => {
info!("{}: Logging in", &self.shared.name);
connected.tear_down(&self.shared)?;
let mut state: LoggedIn = Default::default();
state.setup(&self.shared)?;
self.state = State::LoggedIn(state);
info!(
"{}: Successfully stopped paused streaming",
&self.shared.name
);
}
State::LoggedIn(_) => {
info!("Already logged in");
}
}
Ok(())
}
pub(crate) fn stream(&mut self) -> Result<()> {
match &mut self.state {
State::Connected(_) => {
return Err(anyhow!("{}: Must login first", &self.shared.name));
}
State::Streaming(_) => {
info!("{}: Already streaming", &self.shared.name);
}
State::Paused(ref mut paused) => {
info!("{}: Resuming stream", &self.shared.name);
let outputs = paused.take_outputs()?;
paused.tear_down(&self.shared)?;
let mut state: Streaming = Default::default();
state.insert_outputs(outputs)?;
state.setup(&self.shared)?;
self.state = State::Streaming(state);
info!("{}: Successfully resumed streaming", &self.shared.name);
}
State::LoggedIn(ref mut loggedin) => {
info!("{}: Starting stream", &self.shared.name);
loggedin.tear_down(&self.shared)?;
let mut state: Streaming = Default::default();
state.setup(&self.shared)?;
self.state = State::Streaming(state);
info!("{}: Successfully started streaming", &self.shared.name);
}
}
Ok(())
}
pub(crate) fn pause(&mut self) -> Result<()> {
match &mut self.state {
State::Connected(_) => {
return Err(anyhow!("{}: Must login first", &self.shared.name));
}
State::Streaming(ref mut old_state) => {
info!("{}: Pausing stream", &self.shared.name);
let outputs = old_state.take_outputs()?;
old_state.tear_down(&self.shared)?;
let mut state: Paused = Default::default();
state.insert_outputs(outputs)?;
state.setup(&self.shared)?;
self.state = State::Paused(state);
info!("{}: Successfully paused streaming", &self.shared.name);
}
State::Paused(_) => {
info!("{}: Already paused", &self.shared.name);
}
State::LoggedIn(_) => {
info!(
"{}: Cannot pause a stream that has not started",
&self.shared.name
);
}
}
Ok(())
}
pub(crate) fn client_connected(&self) -> Option<bool> {
match &self.state {
State::Streaming(state) => Some(state.client_connected()),
State::Paused(state) => Some(state.client_connected()),
_ => None,
}
}
pub(crate) fn motion_data(&self) -> Result<MotionData> {
self.shared
.camera
.listen_on_motion()
.with_context(|| "Cannot get motion data")
}
pub(crate) fn is_running(&self) -> bool {
match &self.state {
State::Streaming(state) => state.is_running(),
State::Paused(state) => state.is_running(),
_ => true,
}
}
pub(crate) fn can_pause(&self) -> bool {
match &self.state {
State::Streaming(state) => state.can_pause(),
_ => false,
}
}
pub(crate) fn manage(&self) -> Result<()> {
if let State::Connected(_) = self.state {
return Err(anyhow!("Cannot manage a camera that is not logged in"));
}
let cam_time = self.shared.camera.get_time()?;
if let Some(time) = cam_time {
info!("{}: Camera time is already set: {}", self.shared.name, time);
} else {
use time::OffsetDateTime;
// We'd like now_local() but it's deprecated - try to get the local time, but if no
// time zone, fall back to UTC.
let new_time =
OffsetDateTime::try_now_local().unwrap_or_else(|_| OffsetDateTime::now_utc());
warn!(
"{}: Camera has no time set, setting to {}",
self.shared.name, new_time
);
self.shared.camera.set_time(new_time)?;
let cam_time = self.shared.camera.get_time()?;
if let Some(time) = cam_time {
info!("{}: Camera time is now set: {}", self.shared.name, time);
} else {
error!(
"{}: Camera did not accept new time (is {} an admin?)",
self.shared.name, self.shared.username
);
}
}
use neolink_core::bc::xml::VersionInfo;
if let Ok(VersionInfo {
firmwareVersion: firmware_version,
..
}) = self.shared.camera.version()
{
info!(
"{}: Camera reports firmware version {}",
self.shared.name, firmware_version
);
} else {
info!("{}: Could not fetch version information", self.shared.name);
}
Ok(())
}
}
+183
View File
@@ -0,0 +1,183 @@
// This is the paused state
//
// Video data is not pulled from the camera
// instead dummy data is sent into the gstreamer source
use anyhow::{anyhow, Error, Result};
use crossbeam::utils::Backoff;
use log::*;
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
use neolink_core::bc_protocol::Stream;
use super::{CameraState, Shared};
use crate::rtsp::{
abort::AbortHandle,
gst::{GstOutputs, InputMode, PausedSources},
};
#[derive(Default)]
pub(crate) struct Paused {
handles: HashMap<Stream, JoinHandle<Result<(), anyhow::Error>>>,
outputs: HashMap<Stream, Arc<Mutex<GstOutputs>>>,
abort_handle: AbortHandle,
}
impl CameraState for Paused {
fn setup(&mut self, shared: &Shared) -> Result<(), Error> {
self.abort_handle.reset();
// Create new gst outputs
//
// Otherwise use those already present
if self.outputs.is_empty() {
let paused_source = match shared.pause.mode.as_str() {
"test" => PausedSources::TestSrc,
"still" => PausedSources::Still,
"black" => PausedSources::Black,
"none" => PausedSources::None,
_ => {
unreachable!()
}
};
for stream in shared.streams.iter() {
self.outputs.entry(*stream).or_insert_with_key(|stream| {
let paths = shared.get_paths(stream);
let mut output = shared
.rtsp
.add_stream(
paths
.iter()
.map(|s| s.as_str())
.collect::<Vec<&str>>()
.as_slice(),
&shared.permitted_users,
)
.unwrap();
output.set_paused_source(paused_source);
Arc::new(Mutex::new(output))
});
}
}
// Start the streams on their own thread with a shared abort handle
let abort_handle = self.abort_handle.clone();
for (stream, output) in &self.outputs {
let stream_display_name = match stream {
Stream::Main => "Main Stream (Clear)",
Stream::Sub => "Sub Stream (Fluent)",
Stream::Extern => "Extern Stream (Balanced)",
};
// Lock and setup output
{
let mut locked_output = output.lock().unwrap();
locked_output.set_input_source(InputMode::Paused)?;
}
info!(
"{}: Starting paused stream {}",
&shared.name, stream_display_name
);
let arc_abort_handle = abort_handle.clone();
let output_thread = output.clone();
let handle = thread::spawn(move || {
let backoff = Backoff::new();
while arc_abort_handle.is_live() {
let mut locked_output = output_thread.lock().unwrap();
locked_output.write_last_iframe()?;
backoff.spin();
}
Ok(())
});
self.handles.entry(*stream).or_insert_with(|| handle);
}
Ok(())
}
fn tear_down(&mut self, shared: &Shared) -> Result<(), Error> {
self.abort_handle.abort();
if !self.handles.is_empty() {
for path in shared.get_all_paths().iter() {
if let Err(e) = shared.rtsp.remove_stream(&[path]) {
return Err(anyhow!("Failed to shutdown RTSP Path {}: {:?}", path, e));
}
}
for (stream, handle) in self.handles.drain() {
info!("{}: Stopping paused stream {:?}", &shared.name, stream);
match handle.join() {
Ok(Err(e)) => return Err(e),
Err(_) => return Err(anyhow!("Panicked while streaming {:?}", stream)),
Ok(Ok(_)) => {}
}
}
}
Ok(())
}
}
impl Drop for Paused {
fn drop(&mut self) {
self.abort_handle.abort();
for (stream, handle) in self.handles.drain() {
info!("During_drop: Aborting paused stream {:?}", stream);
if let Ok(Err(e)) = handle.join() {
warn!("During drop: {:?} did not stop cleanly: {:?}", stream, e);
} else {
warn!("During drop: Panicked while streaming: {:?}", stream);
}
}
}
}
impl Paused {
pub(crate) fn is_running(&self) -> bool {
self.handles.iter().all(|(_, h)| !h.is_finished()) && self.abort_handle.is_live()
}
pub(crate) fn take_outputs(&mut self) -> Result<HashMap<Stream, GstOutputs>> {
self.abort_handle.abort();
for (stream, handle) in self.handles.drain() {
match handle.join() {
Ok(Err(e)) => return Err(e),
Err(_) => return Err(anyhow!("Panicked while streaming {:?}", stream)),
Ok(Ok(_)) => {}
}
}
let mut result: HashMap<_, _> = Default::default();
for (stream, arc_mutex_output) in self.outputs.drain() {
let mutex_output =
Arc::try_unwrap(arc_mutex_output).map_err(|_| anyhow!("Failed to unwrap ARC"))?;
let output = mutex_output.into_inner()?;
result.insert(stream, output);
}
Ok(result)
}
pub(crate) fn insert_outputs(&mut self, mut input: HashMap<Stream, GstOutputs>) -> Result<()> {
self.outputs = input
.drain()
.map(|(s, o)| (s, Arc::new(Mutex::new(o))))
.collect();
Ok(())
}
pub(crate) fn client_connected(&self) -> bool {
self.outputs
.iter()
.any(|(_, output)| output.lock().unwrap().is_connected())
}
}
+55
View File
@@ -0,0 +1,55 @@
//!
//! Shared data between all states
//!
//!
use anyhow::{Error, Result};
use std::collections::HashSet;
use std::sync::Arc;
use neolink_core::bc_protocol::{BcCamera, Stream};
use crate::config::PauseConfig;
use crate::rtsp::gst::RtspServer;
use crate::utils::AddressOrUid;
#[allow(dead_code)]
pub(crate) struct Shared {
pub(super) camera: Arc<BcCamera>,
pub(super) name: String,
pub(super) channel: u8,
pub(super) addr: AddressOrUid,
pub(super) username: String,
pub(super) password: Option<String>,
pub(super) streams: HashSet<Stream>,
pub(super) rtsp: Arc<RtspServer>,
pub(super) permitted_users: HashSet<String>,
pub(super) pause: PauseConfig,
}
impl Shared {
pub(super) fn get_all_paths(&self) -> Vec<String> {
self.streams
.iter()
.flat_map(|s| self.get_paths(s))
.collect()
}
pub(super) fn get_paths(&self, stream: &Stream) -> Vec<String> {
match stream {
Stream::Main => vec![
format!("/{}", &self.name),
format!("/{}/mainStream", &self.name),
],
Stream::Sub => vec![format!("/{}/subStream", &self.name)],
Stream::Extern => {
vec![format!("/{}/externStream", &self.name)]
}
}
}
}
pub(crate) trait CameraState: Default {
fn setup(&mut self, shared: &Shared) -> Result<(), Error>;
fn tear_down(&mut self, shared: &Shared) -> Result<(), Error>;
}
+192
View File
@@ -0,0 +1,192 @@
// This is the streaming state
//
// Data is streamed into a gstreamer source
use anyhow::{anyhow, Error, Result};
use crossbeam::utils::Backoff;
use log::*;
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
use neolink_core::bc_protocol::Stream;
use super::{CameraState, Shared};
use crate::rtsp::{
abort::AbortHandle,
gst::{GstOutputs, InputMode, PausedSources},
};
#[derive(Default)]
pub(crate) struct Streaming {
handles: HashMap<Stream, JoinHandle<Result<(), Error>>>,
outputs: HashMap<Stream, Arc<Mutex<GstOutputs>>>,
abort_handle: AbortHandle,
}
impl CameraState for Streaming {
fn setup(&mut self, shared: &Shared) -> Result<(), Error> {
self.abort_handle.reset();
// Create new gst outputs
//
// Otherwise use those already present
if self.outputs.is_empty() {
let paused_source = match shared.pause.mode.as_str() {
"test" => PausedSources::TestSrc,
"still" => PausedSources::Still,
"black" => PausedSources::Black,
"none" => PausedSources::None,
_ => {
unreachable!()
}
};
for stream in shared.streams.iter() {
self.outputs.entry(*stream).or_insert_with_key(|stream| {
let paths = shared.get_paths(stream);
let mut output = shared
.rtsp
.add_stream(
paths
.iter()
.map(|s| s.as_str())
.collect::<Vec<&str>>()
.as_slice(),
&shared.permitted_users,
)
.unwrap();
output.set_paused_source(paused_source);
Arc::new(Mutex::new(output))
});
}
}
// Start the streams on their own thread with a shared abort handle
let camera = &shared.camera;
let abort_handle = self.abort_handle.clone();
for (stream, output) in &self.outputs {
let stream_display_name = match stream {
Stream::Main => "Main Stream (Clear)",
Stream::Sub => "Sub Stream (Fluent)",
Stream::Extern => "Extern Stream (Balanced)",
};
// Lock and setup output
{
let mut locked_output = output.lock().unwrap();
locked_output.set_input_source(InputMode::Live)?;
}
info!(
"{}: Starting video stream {}",
&shared.name, stream_display_name
);
let arc_camera = camera.clone();
let arc_abort_handle = abort_handle.clone();
let output_thread = output.clone();
let stream_thead = *stream;
let handle = thread::spawn(move || {
let backoff = Backoff::new();
let stream_data = arc_camera.start_video(stream_thead, 0)?;
while arc_abort_handle.is_live() {
let mut data = stream_data.get_data()?;
let mut locked_output = output_thread.lock().unwrap();
for datum in data.drain(..) {
locked_output.stream_recv(datum?)?;
}
backoff.spin();
}
Ok(())
});
self.handles.entry(*stream).or_insert_with(|| handle);
}
Ok(())
}
fn tear_down(&mut self, shared: &Shared) -> Result<(), Error> {
self.abort_handle.abort();
if !self.handles.is_empty() {
for path in shared.get_all_paths().iter() {
if let Err(e) = shared.rtsp.remove_stream(&[path]) {
return Err(anyhow!("Failed to shutdown RTSP Path {}: {:?}", path, e));
}
}
for (stream, handle) in self.handles.drain() {
match handle.join() {
Ok(Err(e)) => return Err(e),
Err(_) => return Err(anyhow!("Panicked while streaming {:?}", stream)),
Ok(Ok(_)) => {}
}
}
}
Ok(())
}
}
impl Drop for Streaming {
fn drop(&mut self) {
self.abort_handle.abort();
for (stream, handle) in self.handles.drain() {
if let Ok(Err(e)) = handle.join() {
warn!("During drop: {:?} did not stop cleanly: {:?}", stream, e);
} else {
warn!("During drop: Panicked while streaming");
}
}
}
}
impl Streaming {
pub(crate) fn is_running(&self) -> bool {
self.handles.iter().all(|(_, h)| !h.is_finished()) && self.abort_handle.is_live()
}
pub(crate) fn take_outputs(&mut self) -> Result<HashMap<Stream, GstOutputs>> {
self.abort_handle.abort();
for (stream, handle) in self.handles.drain() {
match handle.join() {
Ok(Err(e)) => return Err(e),
Err(_) => return Err(anyhow!("Panicked while streaming {:?}", stream)),
Ok(Ok(_)) => {}
}
}
let mut result: HashMap<_, _> = Default::default();
for (stream, arc_mutex_output) in self.outputs.drain() {
let mutex_output =
Arc::try_unwrap(arc_mutex_output).map_err(|_| anyhow!("Failed to unwrap ARC"))?;
let output = mutex_output.into_inner()?;
result.insert(stream, output);
}
Ok(result)
}
pub(crate) fn insert_outputs(&mut self, mut input: HashMap<Stream, GstOutputs>) -> Result<()> {
self.outputs = input
.drain()
.map(|(s, o)| (s, Arc::new(Mutex::new(o))))
.collect();
Ok(())
}
pub(crate) fn client_connected(&self) -> bool {
self.outputs
.iter()
.any(|(_, output)| output.lock().unwrap().is_connected())
}
pub(crate) fn can_pause(&self) -> bool {
self.outputs
.iter()
.all(|(_, output)| output.lock().unwrap().has_last_iframe())
}
}
+3 -3
View File
@@ -1,10 +1,10 @@
use anyhow::{anyhow, Context, Result};
use crossbeam_channel::{bounded, Receiver, Sender};
use gstreamer::{
element_error, parse_launch, prelude::*, Caps, ClockTime, FlowError, FlowSuccess, MessageView,
Pipeline, ResourceError, State,
};
use gstreamer_app::{AppSink, AppSinkCallbacks};
use std::sync::mpsc::{sync_channel, Receiver, SyncSender};
use byte_slice_cast::*;
@@ -20,7 +20,7 @@ pub(super) fn from_input(
fn input(pipeline: Pipeline) -> Result<Receiver<Vec<u8>>> {
let appsink = get_sink(&pipeline)?;
let (tx, rx) = sync_channel(30);
let (tx, rx) = bounded(30);
set_data_channel(&appsink, tx);
@@ -69,7 +69,7 @@ fn get_sink(pipeline: &Pipeline) -> Result<AppSink> {
.map_err(|_| anyhow!("Cannot find appsink in gstreamer, check your gstreamer plugins"))
}
fn set_data_channel(appsink: &AppSink, tx: SyncSender<Vec<u8>>) {
fn set_data_channel(appsink: &AppSink, tx: Sender<Vec<u8>>) {
// Getting data out of the appsink is done by setting callbacks on it.
// The appsink will then call those handlers, as soon as data is available.
appsink.set_callbacks(
+1 -1
View File
@@ -54,7 +54,7 @@ pub(crate) fn connect_and_login(camera_config: &CameraConfig) -> Result<BcCamera
camera_config.name, camera_addr
);
let mut camera = camera_addr
let camera = camera_addr
.connect_camera(camera_config.channel_id)
.with_context(|| {
format!(