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

-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!(