diff --git a/Cargo.lock b/Cargo.lock index e81c085..552a254 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -209,6 +209,7 @@ dependencies = [ "anstyle", "bitflags", "clap_lex", + "once_cell", "strsim", ] diff --git a/Cargo.toml b/Cargo.toml index a7e7e6a..c98fcb6 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -14,7 +14,7 @@ members = [ [dependencies] anyhow = "1.0.70" byte-slice-cast = "1.2.2" -clap = { version = "4.2.2", features = ["derive"] } +clap = { version = "4.2.2", features = ["derive", "cargo"] } crossbeam-channel = "0.5.8" env_logger = "*" futures = "0.3.28" diff --git a/crates/core/src/bc_protocol.rs b/crates/core/src/bc_protocol.rs index b6c5af0..11760ac 100644 --- a/crates/core/src/bc_protocol.rs +++ b/crates/core/src/bc_protocol.rs @@ -256,6 +256,7 @@ impl BcCamera { return Ok(CameraLocation::Tcp(addr)); } } + debug!("TCP fail"); // Tcp failed see if Local faired any better // Wait for all local to finish while let Some(result) = local_set.join_next().await { @@ -263,6 +264,7 @@ impl BcCamera { return Ok(CameraLocation::Udp(discovery)); } } + debug!("Local fail"); // Local failed see if Remote faired any better // Wait for all remote to finish while let Some(result) = remote_set.join_next().await { @@ -270,6 +272,7 @@ impl BcCamera { return Ok(CameraLocation::Udp(discovery)); } } + debug!("Remote fail"); // Remote failed see if Map faired any better // Wait for all Map to finish while let Some(result) = map_set.join_next().await { @@ -277,6 +280,7 @@ impl BcCamera { return Ok(CameraLocation::Udp(discovery)); } } + debug!("Map fail"); // Map failed see if Relay faired any better // Wait for all Relay to finish while let Some(result) = relay_set.join_next().await { @@ -284,6 +288,7 @@ impl BcCamera { return Ok(CameraLocation::Udp(discovery)); } } + debug!("Relay (All) fail"); // Nothing works Err(Error::CannotInitCamera) } diff --git a/crates/core/src/bc_protocol/connection/bcconn.rs b/crates/core/src/bc_protocol/connection/bcconn.rs index d4b2160..770a093 100644 --- a/crates/core/src/bc_protocol/connection/bcconn.rs +++ b/crates/core/src/bc_protocol/connection/bcconn.rs @@ -7,8 +7,8 @@ use std::collections::btree_map::Entry; use std::collections::BTreeMap; use std::sync::Arc; use tokio::sync::mpsc::{channel, Sender}; -use tokio::sync::Mutex; use tokio::task::yield_now; +use tokio_stream::wrappers::ReceiverStream; use tokio::{sync::RwLock, task::JoinSet}; @@ -30,21 +30,19 @@ pub(crate) type BcConnSource = Box> + Send + Sync + /// /// There can be only one subscriber per kind of message at a time. pub struct BcConnection { - sink: Arc>, + sink: Sender>, subscribers: Arc, #[allow(dead_code)] // Not dead we just need to hold a reference to keep it alive rx_thread: RwLock>>, } impl BcConnection { - pub async fn new(sink: BcConnSink, mut source: BcConnSource) -> Result { + pub async fn new(mut sink: BcConnSink, mut source: BcConnSource) -> Result { let subscribers: Arc = Default::default(); - let sink = Arc::new(Mutex::new(sink)); - let subs = subscribers.clone(); - + let (sinker, sinker_rx) = channel::>(100); let mut rx_thread = JoinSet::new(); - let sink_thread = sink.clone(); + let sink_thread = sinker.clone(); rx_thread.spawn(async move { loop { yield_now().await; // Give other tasks a chance to run before pulling next packet @@ -57,15 +55,17 @@ impl BcConnection { } }); + rx_thread.spawn(async move { sink.send_all(&mut ReceiverStream::new(sinker_rx)).await }); + Ok(BcConnection { - sink, + sink: sinker, subscribers, rx_thread: RwLock::new(rx_thread), }) } pub(super) async fn send(&self, bc: Bc) -> crate::Result<()> { - self.sink.lock().await.send(bc).await?; + self.sink.send(Ok(bc)).await?; Ok(()) } @@ -114,7 +114,7 @@ impl BcConnection { async fn poll( response: Result, subscribers: &Subscriber, - sink: &Mutex, + sink: &Sender>, ) -> Result<()> { match response { Ok(response) => { @@ -129,7 +129,7 @@ impl BcConnection { (Some(occ), _) => { if let Some(reply) = occ(&response) { assert!(reply.meta.msg_num == response.meta.msg_num); - sink.lock().await.send(reply).await?; + sink.send(Ok(reply)).await?; } } (None, Some(occ)) => { diff --git a/crates/core/src/bc_protocol/connection/bcsub.rs b/crates/core/src/bc_protocol/connection/bcsub.rs index a65fb3e..02c89ac 100644 --- a/crates/core/src/bc_protocol/connection/bcsub.rs +++ b/crates/core/src/bc_protocol/connection/bcsub.rs @@ -48,6 +48,7 @@ impl<'a> Stream for BcPayloadStream<'a> { mut self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll>>> { + // log::debug!("PayloadStream: Poll"); match Pin::new(&mut self.rx).poll_next(cx) { Poll::Ready(Some(Ok(Bc { body: @@ -57,17 +58,27 @@ impl<'a> Stream for BcPayloadStream<'a> { }), .. }))) => { + // log::debug!("PayloadStream: Data"); return Poll::Ready(Some(Ok(data))); } Poll::Ready(Some(Ok(_bc))) => { // trace!("Got other BC in payload stream"); + // log::debug!("PayloadStream: Other Data!"); } Poll::Ready(Some(Err(e))) => { - return Poll::Ready(Some(Err(IoError::new(ErrorKind::Other, e)))) + // log::debug!("PayloadStream: Err"); + return Poll::Ready(Some(Err(IoError::new(ErrorKind::Other, e)))); + } + Poll::Ready(None) => { + // log::debug!("PayloadStream: None"); + return Poll::Ready(None); + } + Poll::Pending => { + // log::debug!("PayloadStream: Pend"); + return Poll::Pending; } - Poll::Ready(None) => return Poll::Ready(None), - Poll::Pending => return Poll::Pending, } + // log::debug!("PayloadStream: Default Pend and Wake"); cx.waker().wake_by_ref(); Poll::Pending } diff --git a/crates/core/src/bc_protocol/connection/discovery.rs b/crates/core/src/bc_protocol/connection/discovery.rs index ef7e696..efebdf8 100644 --- a/crates/core/src/bc_protocol/connection/discovery.rs +++ b/crates/core/src/bc_protocol/connection/discovery.rs @@ -11,7 +11,7 @@ use crate::bcudp::xml::*; use crate::{Error, Result}; use futures::{ sink::SinkExt, - stream::{FuturesUnordered, SplitSink, StreamExt}, + stream::{FuturesUnordered, StreamExt}, }; use lazy_static::lazy_static; use local_ip_address::local_ip; @@ -24,7 +24,7 @@ use tokio::{ net::UdpSocket, sync::{ mpsc::{channel, Receiver, Sender}, - Mutex, RwLock, + RwLock, }, task::JoinSet, time::{interval, timeout, Duration}, @@ -83,7 +83,7 @@ type ArcFramedSocket = UdpFramed>; pub(crate) struct Discoverer { socket: Arc, handle: RwLock>, - writer: Mutex>, + writer: Sender>, subsribers: Subscriber, local_addr: SocketAddr, } @@ -94,7 +94,7 @@ impl Discoverer { let local_addr = socket.local_addr()?; let inner: ArcFramedSocket = UdpFramed::new(socket.clone(), BcUdpCodex::new()); - let (writer, mut reader) = inner.split(); + let (mut writer, mut reader) = inner.split(); let mut set = JoinSet::new(); let subsribers: Subscriber = Default::default(); @@ -138,10 +138,15 @@ impl Discoverer { } }); + let (sinker, sinker_rx) = channel(100); + set.spawn(async move { + let _ = writer.send_all(&mut ReceiverStream::new(sinker_rx)).await; + }); + Ok(Discoverer { socket, handle: RwLock::new(set), - writer: Mutex::new(writer), + writer: sinker, subsribers, local_addr, }) @@ -192,7 +197,10 @@ impl Discoverer { } async fn send(&self, disc: BcUdp, addr: SocketAddr) -> Result<()> { - self.writer.lock().await.send((disc, addr)).await + self.writer + .send(Ok((disc, addr))) + .await + .map_err(Error::from) } fn local_addr(&self) -> &SocketAddr { diff --git a/crates/core/src/bc_protocol/errors.rs b/crates/core/src/bc_protocol/errors.rs index 81a1b09..d7a5687 100644 --- a/crates/core/src/bc_protocol/errors.rs +++ b/crates/core/src/bc_protocol/errors.rs @@ -39,6 +39,10 @@ pub enum Error { #[error(display = "Camera responded with Service Unavaliable")] CameraServiceUnavaliable, + /// Raised when the camera responds with a status code over than OK during login + #[error(display = "Camera responded with Err during login")] + CameraLoginFail, + /// Raised when a connection is dropped. #[error(display = "Dropped connection")] DroppedConnection, @@ -51,6 +55,10 @@ pub enum Error { #[error(display = "Dropped connection")] BroadcastDroppedConnectionTry(#[error(source)] tokio::sync::broadcast::error::TryRecvError), + /// Raised when a connection is dropped during a TryRecv event + #[error(display = "Send Error")] + TokioBcSendError, + /// Raised when the TIMEOUT is reach #[error(display = "Timeout")] Timeout(#[error(source)] std::sync::Arc), @@ -194,6 +202,12 @@ impl From for Error { } } +impl From> for Error { + fn from(_: tokio::sync::mpsc::error::SendError) -> Self { + Error::TokioBcSendError + } +} + impl From for Error { fn from(k: cookie_factory::GenError) -> Self { Error::GenError(std::sync::Arc::new(k)) diff --git a/crates/core/src/bc_protocol/login.rs b/crates/core/src/bc_protocol/login.rs index 4291727..ea9a10a 100644 --- a/crates/core/src/bc_protocol/login.rs +++ b/crates/core/src/bc_protocol/login.rs @@ -136,7 +136,7 @@ impl BcCamera { sub_login.send(modern_login).await?; let modern_reply = sub_login.recv().await?; if modern_reply.meta.response_code != 200 { - return Err(Error::CameraServiceUnavaliable); + return Err(Error::CameraLoginFail); } match modern_reply.body { diff --git a/crates/core/src/bc_protocol/stream.rs b/crates/core/src/bc_protocol/stream.rs index 01424dd..4528c2c 100644 --- a/crates/core/src/bc_protocol/stream.rs +++ b/crates/core/src/bc_protocol/stream.rs @@ -4,7 +4,6 @@ use crate::{ bcmedia::model::*, }; use futures::stream::StreamExt; -use log::*; use std::sync::{ atomic::{AtomicBool, Ordering}, Arc, @@ -51,14 +50,14 @@ impl StreamData { self.abort_handle.store(true, Ordering::Relaxed); return Err(Error::DroppedConnection); } - debug!("StreamData: Get"); + // debug!("StreamData: Get"); match self.rx.recv().await { Some(data) => { - debug!("StreamData: Got"); + // debug!("StreamData: Got"); Ok(data) } None => { - debug!("StreamData: Drop"); + // debug!("StreamData: Drop"); self.abort_handle.store(true, Ordering::Relaxed); Err(Error::DroppedConnection) } @@ -182,22 +181,23 @@ impl BcCamera { let mut media_sub = sub_video.bcmedia_stream(strict); while !abort_handle_thread.load(Ordering::Relaxed) { - debug!("Stream: Get"); + // debug!("Stream: Get"); if let Some(bc_media) = media_sub.next().await { - debug!("Stream: Got"); + // debug!("Stream: Got"); // We now have a complete interesting packet. Send it to on the callback - debug!("Stream: Send"); + // debug!("Stream: Send"); if tx.send(bc_media).await.is_err() { - debug!("Stream: Dropped"); + // debug!("Stream: Dropped"); break; // Connection dropped } - debug!("Stream: Sent"); + // debug!("Stream: Sent"); } else { break; } } } + // debug!("Stream: Stopping"); let stop_video = Bc::new_from_xml( BcMeta { msg_id: MSG_ID_VIDEO_STOP, @@ -217,8 +217,9 @@ impl BcCamera { ..Default::default() }, ); - + // debug!("Stream: Send Stop"); sub_video.send(stop_video).await?; + // debug!("Stream: Sent Stop"); Ok(()) }); diff --git a/crates/core/src/bcmedia/codex.rs b/crates/core/src/bcmedia/codex.rs index b006532..4fc40bc 100644 --- a/crates/core/src/bcmedia/codex.rs +++ b/crates/core/src/bcmedia/codex.rs @@ -4,7 +4,7 @@ //! use crate::bcmedia::model::*; use crate::{Error, Result}; -use bytes::{Buf, BytesMut}; +use bytes::BytesMut; use log::*; use tokio_util::codec::{Decoder, Encoder}; @@ -71,8 +71,9 @@ impl Decoder for BcMediaCodex { debug!("Error in stream attempting to restore"); trace!(" Stream Error: {:?}", e); } - src.advance(1); - amount_skipped += 1; + // Drop the whole packet and wait for a packet that starts with magic + amount_skipped += src.len(); + src.clear(); continue; } } diff --git a/src/cmdline.rs b/src/cmdline.rs index 7552ccc..ea2f319 100644 --- a/src/cmdline.rs +++ b/src/cmdline.rs @@ -1,4 +1,4 @@ -use clap::Parser; +use clap::{crate_authors, crate_version, Parser}; use std::path::PathBuf; use std::str::FromStr; @@ -7,7 +7,7 @@ use std::str::FromStr; /// Neolink is free software released under the GNU AGPL v3. /// You can find its source code at https://github.com/thirtythreeforty/neolink #[derive(Parser, Debug)] -#[command(name = "neolink", arg_required_else_help = true)] +#[command(name = "neolink", arg_required_else_help = true, version = crate_version!(), author = crate_authors!("\n"))] pub struct Opt { #[arg(short, long, global = true, value_parser = PathBuf::from_str)] pub config: Option, diff --git a/src/rtsp/gst/factory.rs b/src/rtsp/gst/factory.rs index 956b25b..7655a60 100644 --- a/src/rtsp/gst/factory.rs +++ b/src/rtsp/gst/factory.rs @@ -12,7 +12,7 @@ use gstreamer::{ Structure, }; use gstreamer::{Bin, Caps, ClockTime, Element, ElementFactory}; -use gstreamer_app::{AppSrc, AppStreamType}; +use gstreamer_app::{AppSrc, AppSrcCallbacks, AppStreamType}; use gstreamer_rtsp::RTSPUrl; use gstreamer_rtsp_server::prelude::*; use gstreamer_rtsp_server::subclass::prelude::*; @@ -139,7 +139,11 @@ impl Default for NeoMediaFactoryImpl { clientdata: Default::default(), waiting_for_iframe: true, }; - threads.spawn(async move { sender.run().await }); + threads.spawn(async move { + let res = sender.run().await; + error!("Factory Run thread stopped: {:?}", res); + res + }); Self { sender: datasender, @@ -209,6 +213,7 @@ impl NeoMediaFactoryImpl { let bin = media .dynamic_cast::() .map_err(|_| anyhow!("Media source's element should be a bin"))?; + let clock = bin.clock(); // Clear the autogenerated ones for element in bin.iterate_elements().into_iter().flatten() { bin.remove(&element)?; @@ -216,6 +221,7 @@ impl NeoMediaFactoryImpl { let mut client_data = ClientPipelineData { start_time: self.shared.microseconds.load(Ordering::Relaxed), + clock, ..Default::default() }; @@ -235,6 +241,25 @@ impl NeoMediaFactoryImpl { source.set_max_bytes(52428800); source.set_do_timestamp(false); source.set_stream_type(AppStreamType::Stream); + + let enough_data_start = client_data.enough_data.clone(); + let enough_data_stop = client_data.enough_data.clone(); + source.set_callbacks( + AppSrcCallbacks::builder() + .need_data(move |_appsrc, _amt| { + if enough_data_stop.load(Ordering::Relaxed) { + log::debug!("Client is in need of data"); + } + enough_data_stop.store(false, Ordering::Relaxed); + }) + .enough_data(move |_appsrc| { + if !enough_data_start.load(Ordering::Relaxed) { + log::debug!("Client is full of of data"); + } + enough_data_start.store(true, Ordering::Relaxed); + }) + .build(), + ); // source.set_caps(Some( // &Caps::builder("video/x-h265").field("parsed", false).build(), // )); @@ -243,6 +268,7 @@ impl NeoMediaFactoryImpl { .map_err(|_| anyhow!("Cannot cast back"))?; let queue = make_element("queue", "source_queue")?; queue.set_property_from_str("leaky", "downstream"); + queue.set_property("max-size-bytes", 104857600u32); let parser = make_element("h265parse", "parser")?; let payload = make_element("rtph265pay", "pay0")?; bin.add_many(&[&source, &queue, &parser, &payload])?; @@ -267,6 +293,25 @@ impl NeoMediaFactoryImpl { source.set_max_bytes(52428800); source.set_do_timestamp(false); source.set_stream_type(AppStreamType::Stream); + + let enough_data_start = client_data.enough_data.clone(); + let enough_data_stop = client_data.enough_data.clone(); + source.set_callbacks( + AppSrcCallbacks::builder() + .need_data(move |_appsrc, _amt| { + if enough_data_stop.load(Ordering::Relaxed) { + log::debug!("Client is in need of data"); + } + enough_data_stop.store(false, Ordering::Relaxed); + }) + .enough_data(move |_appsrc| { + if !enough_data_start.load(Ordering::Relaxed) { + log::debug!("Client is full of of data"); + } + enough_data_start.store(true, Ordering::Relaxed); + }) + .build(), + ); // source.set_caps(Some( // &Caps::builder("video/x-h264").field("parsed", false).build(), // )); @@ -292,6 +337,7 @@ impl NeoMediaFactoryImpl { source.set_property_from_str("pattern", "snow"); let queue = make_element("queue", "queue0")?; queue.set_property_from_str("leaky", "downstream"); + queue.set_property("max-size-bytes", 104857600u32); let overlay = make_element("textoverlay", "overlay")?; overlay.set_property("text", "Stream not Ready"); overlay.set_property_from_str("valignment", "top"); @@ -339,6 +385,7 @@ impl NeoMediaFactoryImpl { let queue = make_element("queue", "audqueue")?; queue.set_property_from_str("leaky", "downstream"); + queue.set_property("max-size-bytes", 104857600u32); let parser = make_element("aacparse", "audparser")?; let decoder = make_element("decodebin", "auddecoder")?; let encoder = make_element("audioconvert", "audencoder")?; @@ -396,6 +443,7 @@ impl NeoMediaFactoryImpl { let queue = make_element("queue", "audqueue")?; queue.set_property_from_str("leaky", "downstream"); + queue.set_property("max-size-bytes", 104857600u32); let decoder = make_element("decodebin", "auddecoder")?; let encoder = make_element("audioconvert", "audencoder")?; let payload = make_element("rtpL16pay", "pay1")?; diff --git a/src/rtsp/gst/sender.rs b/src/rtsp/gst/sender.rs index 8afc8dc..3c62485 100644 --- a/src/rtsp/gst/sender.rs +++ b/src/rtsp/gst/sender.rs @@ -2,7 +2,7 @@ //! gstreamer media stream use anyhow::anyhow; use futures::stream::StreamExt; -use gstreamer::ClockTime; +use gstreamer::{prelude::*, ClockTime}; use gstreamer_app::AppSrc; pub use gstreamer_rtsp_server::gio::{TlsAuthenticationMode, TlsCertificate}; use log::*; @@ -55,16 +55,16 @@ impl NeoMediaSender { self.shared .buffer_ready .store(!buffer_read.is_empty(), Ordering::Relaxed); - debug!("Sender: Get"); + // debug!("Sender: Get"); tokio::select! { v = self.data_source.next() => { - debug!("Sender: Got Data"); + // debug!("Sender: Got Data"); // debug!("data_source recieved"); if let Some(bc_media) = v { - if ! self.skip_bcmedia(&bc_media)? { + if ! self.skip_bcmedia(&bc_media) { // debug!("Not skipped"); // resend_pause.reset(); - self.inspect_bcmedia(&bc_media).await?; + self.inspect_bcmedia(&bc_media).await; match bc_media { BcMedia::Iframe(frame) => { if buffer_write.len() > 100 { @@ -77,7 +77,7 @@ impl NeoMediaSender { ms: frame.microseconds as u64, data: frame.data, }; - self.process_vidbuffer(&new_data).await?; + self.process_vidbuffer(&new_data).await; buffer_write.push(new_data); } BcMedia::Pframe(frame) => { @@ -85,7 +85,7 @@ impl NeoMediaSender { ms: frame.microseconds as u64, data: frame.data, }; - self.process_vidbuffer(&new_data).await?; + self.process_vidbuffer(&new_data).await; buffer_write.push(new_data); } BcMedia::Aac(aac) => { @@ -94,7 +94,7 @@ impl NeoMediaSender { ms: last.ms, data: aac.data, }; - self.process_audbuffer(&new_data).await?; + self.process_audbuffer(&new_data).await; audbuffer_write.push(new_data); } @@ -105,7 +105,7 @@ impl NeoMediaSender { ms: last.ms, data: adpcm.data, }; - self.process_audbuffer(&new_data).await?; + self.process_audbuffer(&new_data).await; audbuffer_write.push(new_data); } @@ -118,7 +118,7 @@ impl NeoMediaSender { } } v = self.clientsource.next() => { - debug!("Sender: Got Client"); + // debug!("Sender: Got Client"); if let Some(mut clientdata) = v { // Resend the video and audio buffers if !clientdata.inited { @@ -176,7 +176,7 @@ impl NeoMediaSender { Ok(()) } - async fn process_vidbuffer(&mut self, stamped_data: &StampedData) -> AnyResult<()> { + async fn process_vidbuffer(&mut self, stamped_data: &StampedData) { for key in self .clientdata .keys() @@ -187,16 +187,35 @@ impl NeoMediaSender { match self.clientdata.entry(key) { Entry::Occupied(data) => { if let Some(vidsrc) = data.get().vidsrc.as_ref() { - if Self::send_buffer( - vidsrc, - stamped_data.data.as_slice(), - stamped_data.ms, - data.get().start_time, - ) - .await - .is_err() - { - data.remove(); + if !data.get().enough_data.load(Ordering::Relaxed) { + let ms = stamped_data.ms; + let st = data.get().start_time; + let micros = ms - st; + if let Some(clock) = data.get().clock.as_ref() { + if let Some(time) = clock.time() { + let buffer_time = ClockTime::from_useconds(micros); + log::debug!( + "Buffer time: {:?}. Clock time: {:?}", + buffer_time, + time + ); + } + } + debug!( + "Pushed Video Buffer: ms: {}, st: {}, delta: {}", + ms, st, micros + ); + if Self::send_buffer( + vidsrc, + stamped_data.data.as_slice(), + stamped_data.ms, + data.get().start_time, + ) + .await + .is_err() + { + data.remove(); + } } } else { data.remove(); @@ -205,10 +224,9 @@ impl NeoMediaSender { Entry::Vacant(_) => {} } } - Ok(()) } - async fn process_audbuffer(&mut self, stamped_data: &StampedData) -> AnyResult<()> { + async fn process_audbuffer(&mut self, stamped_data: &StampedData) { for key in self .clientdata .keys() @@ -219,16 +237,19 @@ impl NeoMediaSender { match self.clientdata.entry(key) { Entry::Occupied(data) => { if let Some(audsrc) = data.get().audsrc.as_ref() { - if Self::send_buffer( - audsrc, - stamped_data.data.as_slice(), - stamped_data.ms, - data.get().start_time, - ) - .await - .is_err() - { - data.remove(); + if !data.get().enough_data.load(Ordering::Relaxed) { + debug!("Pushed Audio Buffer"); + if Self::send_buffer( + audsrc, + stamped_data.data.as_slice(), + stamped_data.ms, + data.get().start_time, + ) + .await + .is_err() + { + data.remove(); + } } } else { data.remove(); @@ -237,8 +258,6 @@ impl NeoMediaSender { Entry::Vacant(_) => {} } } - - Ok(()) } async fn send_buffer( @@ -268,28 +287,38 @@ impl NeoMediaSender { } // debug!("Buffer pushed"); let thread_appsrc = appsrc.clone(); // GObjects are refcounted - tokio::task::spawn_blocking(move || { + let res = tokio::task::spawn_blocking(move || { thread_appsrc .push_buffer(gst_buf.copy()) .map(|_| ()) .map_err(|_| anyhow!("Could not push buffer to appsrc")) }) - .await? + .await; + match &res { + Err(e) => { + error!("Failed to send buffer: {:?}", e); + } + Ok(Err(e)) => { + error!("Failed to send buffer: {:?}", e); + } + Ok(Ok(_)) => {} + }; + res? } - fn skip_bcmedia(&mut self, bc_media: &BcMedia) -> AnyResult { + fn skip_bcmedia(&mut self, bc_media: &BcMedia) -> bool { if self.waiting_for_iframe { if let BcMedia::Iframe(_) = bc_media { self.waiting_for_iframe = false; } else { log::debug!("Skipping bcmedia"); - return Ok(true); + return true; } } - Ok(false) + false } - async fn inspect_bcmedia(&mut self, bc_media: &BcMedia) -> AnyResult<()> { + async fn inspect_bcmedia(&mut self, bc_media: &BcMedia) { let old_vid = *self.shared.vid_format.read().await; let old_aud = *self.shared.aud_format.read().await; match bc_media { @@ -343,6 +372,5 @@ impl NeoMediaSender { if old_aud != new_aud { log::debug!("Audio format set to: {:?} from {:?}", new_aud, old_aud); } - Ok(()) } } diff --git a/src/rtsp/gst/shared.rs b/src/rtsp/gst/shared.rs index f626d98..847119d 100644 --- a/src/rtsp/gst/shared.rs +++ b/src/rtsp/gst/shared.rs @@ -1,8 +1,10 @@ //! Data shared between the various //! components that manage a media stream +use gstreamer::Clock; use gstreamer_app::AppSrc; pub use gstreamer_rtsp_server::gio::{TlsAuthenticationMode, TlsCertificate}; use std::sync::atomic::{AtomicBool, AtomicU64, AtomicUsize}; +use std::sync::Arc; use tokio::sync::RwLock; #[derive(Copy, Clone, Debug, PartialEq, Eq)] @@ -45,4 +47,6 @@ pub(super) struct ClientPipelineData { pub(super) audsrc: Option, pub(super) start_time: u64, pub(super) inited: bool, + pub(super) clock: Option, + pub(super) enough_data: Arc, } diff --git a/src/rtsp/mod.rs b/src/rtsp/mod.rs index 07f8e9d..5957635 100644 --- a/src/rtsp/mod.rs +++ b/src/rtsp/mod.rs @@ -162,7 +162,13 @@ async fn camera_main(camera: Camera) -> Result<(), CameraFailureKi .login() .await .with_context(|| format!("{}: Could not login to camera", name)) - .map_err(CameraFailureKind::Fatal)?; + .map_err(|e| { + let e_inner = e.downcast_ref::().unwrap(); + match e_inner { + neolink_core::Error::CameraLoginFail => CameraFailureKind::Fatal(e), + _ => CameraFailureKind::Retry(e), + } + })?; let _ = loggedin.manage().await; diff --git a/src/rtsp/states/streaming.rs b/src/rtsp/states/streaming.rs index 36ce2df..2cfaa97 100644 --- a/src/rtsp/states/streaming.rs +++ b/src/rtsp/states/streaming.rs @@ -52,21 +52,21 @@ impl Camera { .await?; set.spawn(async move { loop { - debug!("Straming: Get"); + // debug!("Straming: Get"); let data = timeout(Duration::from_secs(15), stream_data.get_data()).await??; - debug!("Straming: Got"); + // debug!("Straming: Got"); match &data { - Ok(BcMedia::InfoV1(_)) => debug!("{}: - InfoV1", &tag_thread), - Ok(BcMedia::InfoV2(_)) => debug!("{}: - InfoV2", &tag_thread), - Ok(BcMedia::Iframe(_)) => debug!("{}: - Iframe", &tag_thread), - Ok(BcMedia::Pframe(_)) => debug!("{}: - Pframe", &tag_thread), - Ok(BcMedia::Aac(_)) => debug!("{}: - Aac", &tag_thread), - Ok(BcMedia::Adpcm(_)) => debug!("{}: - Adpcm", &tag_thread), - Err(_) => debug!(" - Error"), + 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"); + // debug!("Straming: Send"); sender.send(data?).await?; - debug!("Straming: Sent"); + // debug!("Straming: Sent"); } }); }