diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 06f3a7c..9f6d3f8 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -1,6 +1,9 @@ name: CI -on: [push, pull_request, workflow_dispatch] +on: + push: + pull_request: + workflow_dispatch: jobs: pre_job: diff --git a/src/rtsp/mod.rs b/src/rtsp/mod.rs index dcb8ef0..43f7af0 100644 --- a/src/rtsp/mod.rs +++ b/src/rtsp/mod.rs @@ -55,6 +55,8 @@ use anyhow::{anyhow, Context, Result}; use futures::stream::FuturesUnordered; use log::*; +use neolink_core::bc_protocol::{BcCamera, StreamKind}; +use std::collections::HashSet; use std::sync::Arc; use std::time::Duration; use tokio_stream::StreamExt; @@ -242,23 +244,153 @@ async fn camera_main(camera: Camera) -> Result<(), CameraFailureKi .await; log::info!("{}: Buffers prepared", name); + let mut active_tags = streaming.shared.get_streams().clone(); + let mut motion_pause = false; loop { // Wait for error or reason to pause - tokio::select! { + let change = tokio::select! { v = async { - // Wait for error - streaming.join().await - } => { - info!("Join Pause"); - v + // Wait for error + streaming.join().await + }, if ! active_tags.is_empty() => { + info!("{}: Join Pause", name); + Ok(StreamChange::StreamError(v)) }, + v = await_change( + streaming.get_camera(), + &streaming.shared, + &rtsp_thread, + &active_tags, + motion_pause, + &name, + ), if streaming.shared.get_config().pause.on_motion || streaming.shared.get_config().pause.on_disconnect => { + v.with_context(|| format!("{}: Error updating pause state", name)) + .map_err(CameraFailureKind::Retry) + } + }?; + + match change { + StreamChange::StreamError(res) => { + res.map_err(CameraFailureKind::Retry)?; + } + StreamChange::MotionStart => { + motion_pause = false; + let inactive_streams = streaming + .shared + .get_streams() + .iter() + .filter(|i| !active_tags.contains(i)) + .copied() + .collect::>(); + + if streaming.shared.get_config().pause.on_disconnect { + // Pause on client is also on + // + // Only resume clients with active connections + for stream in inactive_streams.iter() { + if rtsp_thread + .get_number_of_clients(streaming.shared.get_tag_for_stream(stream)) + .await + .map(|n| n > 0) + .unwrap_or(false) + { + streaming + .start_stream(*stream) + .await + .map_err(CameraFailureKind::Retry)?; + active_tags.insert(*stream); + rtsp_thread + .resume(streaming.shared.get_tag_for_stream(stream)) + .await + .map_err(CameraFailureKind::Retry)?; + } + } + } else { + // Pause on client is not on + // + // Resume all + for stream in inactive_streams.iter() { + streaming + .start_stream(*stream) + .await + .map_err(CameraFailureKind::Retry)?; + active_tags.insert(*stream); + rtsp_thread + .resume(streaming.shared.get_tag_for_stream(stream)) + .await + .map_err(CameraFailureKind::Retry)?; + } + } + } + StreamChange::MotionStop => { + motion_pause = true; + // Clear all streams + for stream in active_tags.drain() { + rtsp_thread + .pause(streaming.shared.get_tag_for_stream(&stream)) + .await + .map_err(CameraFailureKind::Retry)?; + streaming + .stop_stream(stream) + .await + .map_err(CameraFailureKind::Retry)?; + } + } + StreamChange::ClientStart(stream) => { + if !streaming.shared.get_config().pause.on_motion || !motion_pause { + streaming + .start_stream(stream) + .await + .map_err(CameraFailureKind::Retry)?; + active_tags.insert(stream); + rtsp_thread + .resume(streaming.shared.get_tag_for_stream(&stream)) + .await + .map_err(CameraFailureKind::Retry)?; + } + } + StreamChange::ClientStop(stream) => { + if !streaming.shared.get_config().pause.on_motion || !motion_pause { + rtsp_thread + .pause(streaming.shared.get_tag_for_stream(&stream)) + .await + .map_err(CameraFailureKind::Retry)?; + streaming + .stop_stream(stream) + .await + .map_err(CameraFailureKind::Retry)?; + active_tags.remove(&stream); + } + } + } + } + // Ok(()) +} + +enum StreamChange { + StreamError(Result<()>), + MotionStart, + MotionStop, + ClientStart(StreamKind), + ClientStop(StreamKind), +} +async fn await_change( + camera: &BcCamera, + shared: &Shared, + rtsp_thread: &NeoRtspServer, + active_tags: &HashSet, + motion_pause: bool, + name: &str, +) -> Result { + tokio::select! { v = async { // Wait for motion stop - let mut motion = streaming.get_camera().listen_on_motion().await?; - motion.await_stop(Duration::from_secs_f64(streaming.get_config().pause.motion_timeout)).await - }, if streaming.get_config().pause.on_motion => { - info!("Motion Pause"); - v.map_err(|e| anyhow!("Error while processing motion messages: {:?}", e)) + let mut motion = camera.listen_on_motion().await?; + motion.await_stop(Duration::from_secs_f64(shared.get_config().pause.motion_timeout)).await + }, if motion_pause && shared.get_config().pause.on_motion => { + info!("{}: Motion Pause", name); + v.map_err(|e| anyhow!("Error while processing motion messages: {:?}", e))?; + Ok(StreamChange::MotionStop) }, v = async { // Wait for client to disconnect @@ -266,97 +398,45 @@ async fn camera_main(camera: Camera) -> Result<(), CameraFailureKi loop { inter.tick().await; - let total_clients = tags.iter().map(|tag| rtsp_thread.get_number_of_clients(tag)).collect::>().fold(0usize, |acc, f| acc + f.unwrap_or(0usize)).await; - // info!("Num clients: {}", total_clients); - if total_clients == 0 { - return Ok(()) + for tag in active_tags.iter() { + if rtsp_thread.get_number_of_clients(shared.get_tag_for_stream(tag)).await.map(|n| n == 0).unwrap_or(true) { + return Result::<_,anyhow::Error>::Ok(StreamChange::ClientStop(*tag)) + } } } - }, if streaming.get_config().pause.on_disconnect => { - info!("Client Pause"); + }, if shared.get_config().pause.on_disconnect => { + if let Ok(StreamChange::ClientStop(tag)) = v.as_ref() { + info!("{}: Client Pause:: {:?}", name, tag); + } v }, - }.with_context(|| format!("{}: Error while streaming", name)) - .map_err(CameraFailureKind::Retry)?; - - tags.iter() - .map(|tag| rtsp_thread.pause(tag)) - .collect::>() - .collect::>() - .await; - - let paused = streaming - .stop() - .await - .with_context(|| format!("{}: Could not stop stream", name)) - .map_err(CameraFailureKind::Retry)?; - // Wait for reason to restart - tokio::select! { - v = async { - // Wait for motion start and client for start - let mut motion = paused.get_camera().listen_on_motion().await?; - let mut inter = tokio::time::interval(tokio::time::Duration::from_secs_f32(0.01)); - loop { - motion.await_start(Duration::ZERO).await?; - let total_clients = tags.iter().map(|tag| rtsp_thread.get_number_of_clients(tag)).collect::>().fold(0usize, |acc, f| acc + f.unwrap_or(0usize)).await; - if total_clients > 0 { - return Result::<()>::Ok(()); - } - inter.tick().await; - } - }, if paused.get_config().pause.on_motion && paused.get_config().pause.on_disconnect => { - info!("Motion and Client Resume"); - v.with_context(|| "Error while processing motion/client messages") - }, v = async { // Wait for motion start - let mut motion = paused.get_camera().listen_on_motion().await?; + let mut motion = camera.listen_on_motion().await?; motion.await_start(Duration::ZERO).await - }, if paused.get_config().pause.on_motion && !paused.get_config().pause.on_disconnect => { - info!("Motion Resume"); - v.with_context(|| "Error while processing motion messages") + }, if ! motion_pause && shared.get_config().pause.on_motion => { + info!("{}: Motion Resume", name); + v.with_context(|| "Error while processing motion messages")?; + Ok(StreamChange::MotionStart) }, v = async { // Wait for client to connect let mut inter = tokio::time::interval(tokio::time::Duration::from_secs_f32(0.01)); - + let inactive_tags = shared.get_streams().iter().filter(|i| !active_tags.contains(i)).collect::>(); + trace!("inactive_tags: {:?}", inactive_tags); loop { inter.tick().await; - let total_clients = tags.iter().map(|tag| rtsp_thread.get_number_of_clients(tag)).collect::>().fold(0usize, |acc, f| acc + f.unwrap_or(0usize)).await; - if total_clients > 0 { - return Ok(()) + for tag in inactive_tags.iter() { + if rtsp_thread.get_number_of_clients(shared.get_tag_for_stream(tag)).await.map(|n| n > 0).unwrap_or(false) { + return Result::<_,anyhow::Error>::Ok(StreamChange::ClientStart(**tag)) + } } } - }, if paused.get_config().pause.on_disconnect && !paused.get_config().pause.on_motion => { - info!("Client Resume"); + }, if shared.get_config().pause.on_disconnect => { + if let Ok(StreamChange::ClientStart(tag)) = v.as_ref() { + info!("{}: Client Resume:: {:?}", name, tag); + } v }, - else => { - // No pause. This means that the stream stopped for some reason - // but not because of an error - info!("Generic Resume"); - Ok(()) - } - } - .with_context(|| format!("{}: Error while paused", name)) - .map_err(CameraFailureKind::Retry)?; - - tags.iter() - .map(|tag| rtsp_thread.jump_to_live(tag)) - .collect::>() - .collect::>() - .await; - - streaming = paused - .stream() - .await - .with_context(|| format!("{}: Could not start stream", name)) - .map_err(CameraFailureKind::Retry)?; - - tags.iter() - .map(|tag| rtsp_thread.resume(tag)) - .collect::>() - .collect::>() - .await; - } + }.with_context(|| format!("{}: Error while streaming", name)) } diff --git a/src/rtsp/states/camera.rs b/src/rtsp/states/camera.rs index a5936a1..de11c92 100644 --- a/src/rtsp/states/camera.rs +++ b/src/rtsp/states/camera.rs @@ -15,6 +15,7 @@ impl Camera { self.shared.config.name.clone() } + #[allow(dead_code)] pub(crate) fn get_config(&self) -> &CameraConfig { &self.shared.config } diff --git a/src/rtsp/states/loggedin.rs b/src/rtsp/states/loggedin.rs index fef2b53..84c90a7 100644 --- a/src/rtsp/states/loggedin.rs +++ b/src/rtsp/states/loggedin.rs @@ -93,6 +93,7 @@ impl Camera { Ok(()) } + #[allow(dead_code)] pub(crate) fn get_camera(&self) -> &BcCamera { &self.state.camera } diff --git a/src/rtsp/states/shared.rs b/src/rtsp/states/shared.rs index 22409f5..9c5e782 100644 --- a/src/rtsp/states/shared.rs +++ b/src/rtsp/states/shared.rs @@ -102,6 +102,12 @@ impl Shared { .map(|k| self.get_tag_for_stream(k)) .collect() } + pub(crate) fn get_streams(&self) -> &HashSet { + &self.streams + } + pub(crate) fn get_config(&self) -> &CameraConfig { + &self.config + } pub(crate) fn get_tag_for_stream(&self, stream: &Stream) -> String { format!("{}::{:?}", self.config.name, stream) } diff --git a/src/rtsp/states/streaming.rs b/src/rtsp/states/streaming.rs index 44b53f6..01dbf11 100644 --- a/src/rtsp/states/streaming.rs +++ b/src/rtsp/states/streaming.rs @@ -2,11 +2,16 @@ // // Data is streamed into a gstreamer source +use std::collections::HashMap; + +use futures::stream::{FuturesUnordered, StreamExt}; + use anyhow::{anyhow, Context, Error, Result}; use log::*; use neolink_core::bcmedia::model::BcMedia; +use tokio::sync::RwLock; +use tokio::task::JoinHandle; use tokio::time::{timeout, Duration}; -use tokio::{sync::RwLock, task::JoinSet}; use neolink_core::bc_protocol::{BcCamera, StreamKind as Stream}; @@ -15,7 +20,7 @@ use crate::rtsp::gst::FactoryCommand; pub(crate) struct Streaming { pub(crate) camera: BcCamera, - set: RwLock>>, + stream_handles: RwLock>>>, } impl Camera { @@ -23,74 +28,98 @@ impl Camera { // Create new gst outputs // // Otherwise use those already present - let mut set: JoinSet> = Default::default(); - for stream in loggedin.shared.streams.iter() { - let tag = loggedin.shared.get_tag_for_stream(stream); - let sender = loggedin - .shared - .rtsp - .get_sender(&tag) - .await - .ok_or_else(|| anyhow!("Stream has not been created"))?; - - let stream_display_name = match stream { - Stream::Main => "Main Stream (Clear)", - Stream::Sub => "Sub Stream (Fluent)", - Stream::Extern => "Extern Stream (Balanced)", - }; - info!( - "{}: Starting video stream {}", - &loggedin.shared.config.name, stream_display_name - ); - - let stream_thead = *stream; - let strict_thread = loggedin.shared.config.strict; - let tag_thread = tag.clone(); - let mut stream_data = loggedin - .state - .camera - .start_video(stream_thead, 0, strict_thread) - .await?; - set.spawn(async move { - loop { - tokio::task::yield_now().await; - // debug!("Straming: Get"); - let data = timeout(Duration::from_secs(15), stream_data.get_data()) - .await - .with_context(|| "Timed out waiting for new Media Frame")??; - // debug!("Straming: Got"); - match &data { - Ok(BcMedia::InfoV1(_)) => trace!("{}: - InfoV1", &tag_thread), - Ok(BcMedia::InfoV2(_)) => trace!("{}: - InfoV2", &tag_thread), - Ok(BcMedia::Iframe(_)) => trace!("{}: - Iframe", &tag_thread), - Ok(BcMedia::Pframe(_)) => trace!("{}: - Pframe", &tag_thread), - Ok(BcMedia::Aac(_)) => trace!("{}: - Aac", &tag_thread), - Ok(BcMedia::Adpcm(_)) => trace!("{}: - Adpcm", &tag_thread), - Err(_) => trace!(" - Error"), - } - // debug!("Straming: Send"); - timeout( - Duration::from_secs(15), - sender.send(FactoryCommand::BcMedia(data?)), - ) - .await - .with_context(|| "Timed out waiting to send Media Frame")??; - // debug!("Straming: Sent"); - } - }); - } - - Ok(Camera { + let mut me = Camera { shared: loggedin.shared, state: Streaming { camera: loggedin.state.camera, - set: RwLock::new(set), + stream_handles: Default::default(), }, - }) + }; + + for stream in me.shared.streams.iter().copied().collect::>() { + me.start_stream(stream).await?; + } + + Ok(me) } + pub(crate) async fn start_stream(&mut self, stream: Stream) -> Result<()> { + if let Some(handle) = self.state.stream_handles.get_mut().get(&stream) { + if !handle.is_finished() { + return Ok(()); + } + } + let tag = self.shared.get_tag_for_stream(&stream); + let sender = self + .shared + .rtsp + .get_sender(&tag) + .await + .ok_or_else(|| anyhow!("Stream has not been created"))?; + + let stream_display_name = match stream { + Stream::Main => "Main Stream (Clear)", + Stream::Sub => "Sub Stream (Fluent)", + Stream::Extern => "Extern Stream (Balanced)", + }; + info!( + "{}: Starting video stream {}", + &self.shared.config.name, stream_display_name + ); + + let stream_thead = stream; + let strict_thread = self.shared.config.strict; + let tag_thread = tag.clone(); + let mut stream_data = self + .state + .camera + .start_video(stream_thead, 0, strict_thread) + .await?; + let handle = tokio::task::spawn(async move { + loop { + tokio::task::yield_now().await; + // debug!("Straming: Get"); + let data = timeout(Duration::from_secs(15), stream_data.get_data()) + .await + .with_context(|| "Timed out waiting for new Media Frame")??; + // debug!("Straming: Got"); + match &data { + Ok(BcMedia::InfoV1(_)) => trace!("{}: - InfoV1", &tag_thread), + Ok(BcMedia::InfoV2(_)) => trace!("{}: - InfoV2", &tag_thread), + Ok(BcMedia::Iframe(_)) => trace!("{}: - Iframe", &tag_thread), + Ok(BcMedia::Pframe(_)) => trace!("{}: - Pframe", &tag_thread), + Ok(BcMedia::Aac(_)) => trace!("{}: - Aac", &tag_thread), + Ok(BcMedia::Adpcm(_)) => trace!("{}: - Adpcm", &tag_thread), + Err(_) => trace!(" - Error"), + } + // debug!("Straming: Send"); + timeout( + Duration::from_secs(15), + sender.send(FactoryCommand::BcMedia(data?)), + ) + .await + .with_context(|| "Timed out waiting to send Media Frame")??; + // debug!("Straming: Sent"); + } + }); + self.state.stream_handles.get_mut().insert(stream, handle); + Ok(()) + } + + pub(crate) async fn stop_stream(&mut self, stream: Stream) -> Result<()> { + if let Some(handle) = self.state.stream_handles.get_mut().remove(&stream) { + handle.abort(); + } + Ok(()) + } + + #[allow(dead_code)] pub(crate) async fn stop(self) -> Result> { - self.state.set.into_inner().abort_all(); + self.state + .stream_handles + .into_inner() + .into_values() + .for_each(|h| h.abort()); Ok(Camera { shared: self.shared, state: LoggedIn { @@ -102,15 +131,19 @@ impl Camera { pub(crate) async fn join(&self) -> Result<()> { tokio::select! { v = async { - let mut locked_threads = self.state.set.write().await; - while let Some(res) = locked_threads.join_next().await { + let mut locked_threads = self.state.stream_handles.write().await; + let mut thread_joins = locked_threads.iter_mut().map(|(_, t)| t).collect::>(); + + while let Some(res) = thread_joins.next().await { match res { Err(e) => { - locked_threads.abort_all(); + drop(thread_joins); + locked_threads.iter_mut().for_each(|(_,h)| h.abort()); return Err(e.into()); } Ok(Err(e)) => { - locked_threads.abort_all(); + drop(thread_joins); + locked_threads.iter_mut().for_each(|(_,h)| h.abort()); return Err(e); } Ok(Ok(())) => {}