Make buffer size configurable

This commit is contained in:
QuantumEntangledAndy committed 2023-05-16 18:25:39 +07:00
1 parent f5ac615b3c
commit 951a822973
7 files changed
+120 -24

No files matched your search

+16
View File
@@ -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"
+24
View File
@@ -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() {
+9 -3
View File
@@ -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::<NeoMediaFactory>();
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 (
+35 -15
View File
@@ -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<Arc<BcMedia>>,
}
#[derive(Default, Debug)]
#[derive(Debug)]
struct NeoBuffer {
buf: VecDeque<Stamped>,
max_size: usize,
}
impl NeoBuffer {
fn new(max_size: usize) -> Self {
Self {
buf: Default::default(),
max_size,
}
}
fn push(&mut self, media: Arc<BcMedia>) {
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<FrameTime> {
@@ -197,6 +211,7 @@ impl NeoMediaSenders {
shared: Arc<NeoMediaShared>,
data_source: ReceiverStream<FactoryCommand>,
client_source: ReceiverStream<NeoMediaSender>,
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<FrameTime> {
let target_idx = BUFFER_SIZE / 3;
let target_idx = buffer.live_size();
let stamps = buffer.buf.iter().map(|item| item.time).collect::<Vec<_>>();
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?;
+12 -4
View File
@@ -52,8 +52,12 @@ impl NeoRtspServer {
self.imp().get_sender(tag).await
}
pub(crate) async fn create_stream<U: Into<String>>(&self, tag: U) -> AnyResult<()> {
self.imp().create_stream(tag).await
pub(crate) async fn create_stream<U: Into<String>>(
&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<U: Into<String>>(&self, tag: U) -> AnyResult<()> {
pub(crate) async fn create_stream<U: Into<String>>(
&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()
+23 -1
View File
@@ -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<AudFormats>,
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)
}
}
+1 -1
View File
@@ -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?;