From 951a822973c6a4fef14251510022cd33116d2e5f Mon Sep 17 00:00:00 2001 From: QuantumEntangledAndy Date: Tue, 16 May 2023 18:25:39 +0700 Subject: [PATCH] Make buffer size configurable --- sample_config.toml | 16 +++++++++++++ src/config.rs | 24 +++++++++++++++++++ src/rtsp/gst/factory.rs | 12 +++++++--- src/rtsp/gst/sender.rs | 50 +++++++++++++++++++++++++++------------ src/rtsp/gst/server.rs | 16 +++++++++---- src/rtsp/gst/shared.rs | 24 ++++++++++++++++++- src/rtsp/states/shared.rs | 2 +- 7 files changed, 120 insertions(+), 24 deletions(-) diff --git a/sample_config.toml b/sample_config.toml index d1879a8..4fb6735 100644 --- a/sample_config.toml +++ b/sample_config.toml @@ -75,6 +75,22 @@ address = "192.168.1.187:9000" # # print_format = "None" +# Internally neolink uses a buffer to improve delivery of frames at their actual times +# A large buffer can work even for large interupts in the connection with the camera +# A small buffer will reduce the latency introduced +# buffer_size: 100 + +# Over long periods of time the camera buffer can exhaust with no means of recovery +# to combat this a time stretching stratery is employed where the stream is slowed +# as the buffer is exhausted and sped up when full +# this can keep the camera and rtsp streams in sync and reduce buffer exhaustions +# +# HOWEVER if there is real latency issues (such as too high a bitrate) +# then smoothing can result in a stream appearing in slow motion +# +# you can disable and enable this feature here +# use_smoothing: true + [[cameras]] name = "storage shed" diff --git a/src/config.rs b/src/config.rs index 78b3c8a..2cfd870 100644 --- a/src/config.rs +++ b/src/config.rs @@ -102,6 +102,22 @@ pub(crate) struct CameraConfig { #[serde(default = "default_update_time", alias = "time")] pub(crate) update_time: bool, + + #[validate(range( + min = 10, + max = 500, + message = "Invalid buffer size", + code = "buffer_size" + ))] + #[serde(default = "default_buffer_size", alias = "size", alias = "buffer")] + pub(crate) buffer_size: usize, + + #[serde( + default = "default_smoothing", + alias = "smoothing", + alias = "stretching" + )] + pub(crate) use_smoothing: bool, } #[derive(Debug, Deserialize, Validate, Clone)] @@ -239,6 +255,14 @@ fn default_pause() -> PauseConfig { } } +fn default_smoothing() -> bool { + true +} + +fn default_buffer_size() -> usize { + 100 +} + pub(crate) static RESERVED_NAMES: &[&str] = &["anyone", "anonymous"]; fn validate_username(name: &str) -> Result<(), ValidationError> { if name.trim().is_empty() { diff --git a/src/rtsp/gst/factory.rs b/src/rtsp/gst/factory.rs index 69a7896..6c4426a 100644 --- a/src/rtsp/gst/factory.rs +++ b/src/rtsp/gst/factory.rs @@ -41,14 +41,16 @@ glib::wrapper! { impl Default for NeoMediaFactory { fn default() -> Self { - Self::new() + Self::new(100, true) } } impl NeoMediaFactory { - pub(crate) fn new() -> Self { + pub(crate) fn new(buffer_size: usize, use_smoothing: bool) -> Self { let factory = Object::new::(); factory.set_shared(false); + factory.imp().shared.set_buffer_size(buffer_size); + factory.imp().shared.set_use_smoothing(use_smoothing); // factory.set_do_retransmission(false); // Can't use as the method is missing on the 32bit docker gst dll factory.set_launch("videotestsrc pattern=\"snow\" ! video/x-raw,width=896,height=512,framerate=25/1 ! textoverlay name=\"inittextoverlay\" text=\"Stream not Ready\" valignment=top halignment=left font-desc=\"Sans, 32\" ! jpegenc ! rtpjpegpay name=pay0"); factory.set_suspend_mode(RTSPSuspendMode::None); @@ -151,6 +153,7 @@ impl Default for NeoMediaFactoryImpl { shared.clone(), ReceiverStream::new(datarx), ReceiverStream::new(rx_clientsender), + 100, ); threads.spawn(async move { loop { @@ -267,7 +270,10 @@ impl NeoMediaFactoryImpl { bin.remove(&element)?; } - let mut client_data = NeoMediaSender::new(); + let mut client_data = NeoMediaSender::new( + self.shared.get_buffer_size(), + self.shared.get_use_smoothing(), + ); // Now contruct the actual ones match ( diff --git a/src/rtsp/gst/sender.rs b/src/rtsp/gst/sender.rs index 5ba5b06..c4c2bd3 100644 --- a/src/rtsp/gst/sender.rs +++ b/src/rtsp/gst/sender.rs @@ -31,20 +31,26 @@ use crate::rtsp::Spring; type FrameTime = i64; -const BUFFER_SIZE: usize = 100; - #[derive(Debug, Clone)] struct Stamped { time: FrameTime, data: Vec>, } -#[derive(Default, Debug)] +#[derive(Debug)] struct NeoBuffer { buf: VecDeque, + max_size: usize, } impl NeoBuffer { + fn new(max_size: usize) -> Self { + Self { + buf: Default::default(), + max_size, + } + } + fn push(&mut self, media: Arc) { let frame_time = match media.as_ref() { BcMedia::Iframe(data) => Some(data.microseconds as FrameTime), @@ -92,19 +98,27 @@ impl NeoBuffer { last.data.push(media); } - while self.buf.len() > BUFFER_SIZE { + while self.buf.len() > self.max_size { if self.buf.pop_front().is_none() { break; } } } + fn prep_size(&self) -> usize { + self.max_size * 2 / 3 + } + + fn live_size(&self) -> usize { + self.max_size / 3 + } + pub(crate) fn ready(&self) -> bool { - self.buf.len() > BUFFER_SIZE * 2 / 3 + self.buf.len() > self.prep_size() } pub(crate) fn ready_play(&self) -> bool { - self.buf.len() > BUFFER_SIZE / 3 + self.buf.len() > self.live_size() } // fn last_iframe_time(&self) -> Option { @@ -197,6 +211,7 @@ impl NeoMediaSenders { shared: Arc, data_source: ReceiverStream, client_source: ReceiverStream, + buffer_size: usize, ) -> Self { Self { data_source, @@ -204,7 +219,7 @@ impl NeoMediaSenders { shared, uid: Default::default(), client_data: Default::default(), - buffer: Default::default(), + buffer: NeoBuffer::new(buffer_size), } } @@ -407,6 +422,7 @@ impl NeoMediaSenders { } async fn update(&mut self) -> AnyResult<()> { + self.buffer.max_size = self.shared.get_buffer_size(); self.init_clients().await?; self.process_client_commands().await?; self.process_client_update().await?; @@ -493,15 +509,16 @@ pub(super) struct NeoMediaSender { inited: bool, playing: bool, refilling: bool, + use_smoothing: bool, } impl NeoMediaSender { - pub(super) fn new() -> Self { + pub(super) fn new(buffer_size: usize, use_smoothing: bool) -> Self { let (tx, rx) = channel(30); Self { start_time: Spring::new(0.0, 0.0, 10.0), live_offset: 0, - buffer: NeoBuffer::default(), + buffer: NeoBuffer::new(buffer_size), vid: None, aud: None, command_reciever: rx, @@ -509,6 +526,7 @@ impl NeoMediaSender { inited: false, playing: true, refilling: false, + use_smoothing, } } @@ -530,7 +548,7 @@ impl NeoMediaSender { } fn target_live_for(buffer: &NeoBuffer) -> Option { - let target_idx = BUFFER_SIZE / 3; + let target_idx = buffer.live_size(); let stamps = buffer.buf.iter().map(|item| item.time).collect::>(); if stamps.len() >= target_idx { @@ -602,8 +620,10 @@ impl NeoMediaSender { async fn update_starttime(&mut self) -> AnyResult<()> { self.start_time.update().await; - if let (Some(runtime), Some(target_time)) = (self.get_runtime(), self.target_live()) { - self.start_time.set_target((target_time - runtime) as f64); + if self.use_smoothing { + if let (Some(runtime), Some(target_time)) = (self.get_runtime(), self.target_live()) { + self.start_time.set_target((target_time - runtime) as f64); + } } Ok(()) } @@ -720,7 +740,7 @@ impl NeoMediaSender { } async fn update(&mut self) -> AnyResult<()> { - if self.buffer.buf.len() > BUFFER_SIZE - 5 { + if self.buffer.buf.len() > self.buffer.max_size - 5 { debug!("Buffer overfull"); self.jump_to_live().await?; } @@ -731,8 +751,8 @@ impl NeoMediaSender { debug!( "Refilling: {}/{} ({:.2}%)", self.buffer.buf.len(), - BUFFER_SIZE / 3, - self.buffer.buf.len() as f32 / (BUFFER_SIZE / 3) as f32 * 100.0 + self.buffer.live_size(), + self.buffer.buf.len() as f32 / (self.buffer.live_size()) as f32 * 100.0 ); } else if !self.refilling && self.inited && self.playing { self.update_starttime().await?; diff --git a/src/rtsp/gst/server.rs b/src/rtsp/gst/server.rs index 56ce5f3..52728b2 100644 --- a/src/rtsp/gst/server.rs +++ b/src/rtsp/gst/server.rs @@ -52,8 +52,12 @@ impl NeoRtspServer { self.imp().get_sender(tag).await } - pub(crate) async fn create_stream>(&self, tag: U) -> AnyResult<()> { - self.imp().create_stream(tag).await + pub(crate) async fn create_stream>( + &self, + tag: U, + config: &CameraConfig, + ) -> AnyResult<()> { + self.imp().create_stream(tag, config).await } #[allow(dead_code)] @@ -350,12 +354,16 @@ impl ObjectSubclass for NeoRtspServerImpl { } impl NeoRtspServerImpl { - pub(crate) async fn create_stream>(&self, tag: U) -> AnyResult<()> { + pub(crate) async fn create_stream>( + &self, + tag: U, + config: &CameraConfig, + ) -> AnyResult<()> { let key = tag.into(); match self.medias.write().await.entry(key.clone()) { Entry::Occupied(_occ) => {} Entry::Vacant(vac) => { - let media = NeoMediaFactory::new(); + let media = NeoMediaFactory::new(config.buffer_size, config.use_smoothing); let thread_media = media.clone(); self.threads .write() diff --git a/src/rtsp/gst/shared.rs b/src/rtsp/gst/shared.rs index 685695f..ad466b7 100644 --- a/src/rtsp/gst/shared.rs +++ b/src/rtsp/gst/shared.rs @@ -1,7 +1,7 @@ //! Data shared between the various //! components that manage a media stream pub use gstreamer_rtsp_server::gio::{TlsAuthenticationMode, TlsCertificate}; -use std::sync::atomic::{AtomicBool, AtomicUsize}; +use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; use tokio::sync::RwLock; #[derive(Copy, Clone, Debug, PartialEq, Eq)] @@ -23,6 +23,8 @@ pub(super) struct NeoMediaShared { pub(super) aud_format: RwLock, pub(super) number_of_clients: AtomicUsize, pub(super) buffer_ready: AtomicBool, + pub(super) buffer_size: AtomicUsize, + pub(super) use_smoothing: AtomicBool, } impl Default for NeoMediaShared { @@ -32,6 +34,26 @@ impl Default for NeoMediaShared { aud_format: RwLock::new(AudFormats::Unknown), number_of_clients: AtomicUsize::new(0), buffer_ready: AtomicBool::new(false), + buffer_size: AtomicUsize::new(100), + use_smoothing: AtomicBool::new(false), } } } + +impl NeoMediaShared { + pub(super) fn get_buffer_size(&self) -> usize { + self.buffer_size.load(Ordering::Relaxed) + } + + pub(super) fn set_buffer_size(&self, new_size: usize) { + self.buffer_size.store(new_size, Ordering::Relaxed) + } + + pub(super) fn get_use_smoothing(&self) -> bool { + self.use_smoothing.load(Ordering::Relaxed) + } + + pub(super) fn set_use_smoothing(&self, new_value: bool) { + self.use_smoothing.store(new_value, Ordering::Relaxed) + } +} diff --git a/src/rtsp/states/shared.rs b/src/rtsp/states/shared.rs index 29062a4..22409f5 100644 --- a/src/rtsp/states/shared.rs +++ b/src/rtsp/states/shared.rs @@ -85,7 +85,7 @@ impl Shared { pub(crate) async fn setup_streams(&self) -> Result<()> { for stream in self.streams.iter() { let tag = self.get_tag_for_stream(stream); - self.rtsp.create_stream(&tag).await?; + self.rtsp.create_stream(&tag, &self.config).await?; self.rtsp .add_permitted_roles(&tag, &self.permitted_users) .await?;