Change how frames are popped from buffer. Change how target time is updated
This commit is contained in:
9 files changed
+362
-224
No files matched your search
Generated
+1
@@ -1415,6 +1415,7 @@ dependencies = [
|
||||
"gstreamer-app",
|
||||
"gstreamer-rtsp",
|
||||
"gstreamer-rtsp-server",
|
||||
"itertools",
|
||||
"lazy_static",
|
||||
"log",
|
||||
"neolink_core",
|
||||
|
||||
+2
-1
@@ -23,8 +23,9 @@ gstreamer = "0.20.3"
|
||||
gstreamer-app = "0.20.0"
|
||||
gstreamer-rtsp = "0.20.0"
|
||||
gstreamer-rtsp-server = { version = "0.20.3", features = ["v1_16"] }
|
||||
itertools = "0.10.5"
|
||||
lazy_static = "1.4.0"
|
||||
log = "0.4.17"
|
||||
log = { version = "0.4.17", features = [ "release_max_level_debug" ] }
|
||||
neolink_core = { path = "crates/core", version = "0.5.8" }
|
||||
regex = "1.7.3"
|
||||
rumqttc = "0.20.0"
|
||||
|
||||
+1
-1
@@ -6,7 +6,7 @@ mod sender;
|
||||
mod server;
|
||||
mod shared;
|
||||
|
||||
use factory::*;
|
||||
pub(crate) use factory::*;
|
||||
|
||||
pub(crate) use self::server::NeoRtspServer;
|
||||
|
||||
|
||||
@@ -56,7 +56,7 @@ impl NeoMediaFactory {
|
||||
factory
|
||||
}
|
||||
|
||||
pub(crate) fn get_sender(&self) -> Sender<BcMedia> {
|
||||
pub(crate) fn get_sender(&self) -> Sender<FactoryCommand> {
|
||||
self.imp().sender.clone()
|
||||
}
|
||||
|
||||
@@ -115,8 +115,15 @@ impl NeoMediaFactory {
|
||||
unsafe impl Send for NeoMediaFactory {}
|
||||
unsafe impl Sync for NeoMediaFactory {}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub(crate) enum FactoryCommand {
|
||||
BcMedia(BcMedia),
|
||||
ClearBuffer,
|
||||
JumpToLive,
|
||||
}
|
||||
|
||||
pub(crate) struct NeoMediaFactoryImpl {
|
||||
sender: Sender<BcMedia>,
|
||||
sender: Sender<FactoryCommand>,
|
||||
clientsender: Sender<NeoMediaSender>,
|
||||
shared: Arc<NeoMediaShared>,
|
||||
#[allow(dead_code)] // Not dead just need a handle to keep it alive and drop with this obj
|
||||
|
||||
+189
-198
@@ -5,6 +5,7 @@ use futures::stream::StreamExt;
|
||||
use gstreamer::{prelude::*, ClockTime};
|
||||
use gstreamer_app::AppSrc;
|
||||
pub use gstreamer_rtsp_server::gio::{TlsAuthenticationMode, TlsCertificate};
|
||||
use itertools::Itertools;
|
||||
use log::*;
|
||||
use neolink_core::bcmedia::model::*;
|
||||
use std::sync::{
|
||||
@@ -20,11 +21,12 @@ use std::{
|
||||
};
|
||||
use tokio::{
|
||||
sync::mpsc::{channel, Receiver, Sender},
|
||||
time::{Duration, Instant},
|
||||
time::Duration,
|
||||
};
|
||||
use tokio_stream::wrappers::ReceiverStream;
|
||||
|
||||
use super::{shared::*, AnyResult};
|
||||
use super::{factory::FactoryCommand, shared::*, AnyResult};
|
||||
use crate::rtsp::Spring;
|
||||
|
||||
type FrameTime = i64;
|
||||
|
||||
@@ -34,122 +36,106 @@ const MILLIS: FrameTime = 1000;
|
||||
|
||||
const LATENCY: FrameTime = 20 * MILLIS;
|
||||
const BUFFER_TIME: FrameTime = 10 * SECS;
|
||||
const BUFFER_SIZE: usize = 3;
|
||||
const BUFFER_SIZE: usize = 100;
|
||||
|
||||
#[derive(Default)]
|
||||
struct NeoBuffer {
|
||||
buf: VecDeque<Vec<BcMedia>>,
|
||||
buf: VecDeque<BcMedia>,
|
||||
}
|
||||
|
||||
impl NeoBuffer {
|
||||
fn push(&mut self, item: BcMedia) {
|
||||
let mut was_iframe = false;
|
||||
match item {
|
||||
BcMedia::Iframe(data) => {
|
||||
debug!(
|
||||
"Pushed iFrame to buffer at {:?}",
|
||||
Duration::from_micros(data.microseconds.try_into().unwrap())
|
||||
);
|
||||
was_iframe = true;
|
||||
self.buf.push_back(vec![BcMedia::Iframe(data)])
|
||||
}
|
||||
pframe @ BcMedia::Pframe(_) => {
|
||||
if let Some(last) = self.buf.back_mut().as_mut() {
|
||||
last.push(pframe);
|
||||
self.buf.push_back(item);
|
||||
let (fronts, backs) = self.buf.as_slices();
|
||||
let last_frame = backs
|
||||
.iter()
|
||||
.rev()
|
||||
.chain(&mut fronts.iter().rev())
|
||||
.flat_map(|frame| match frame {
|
||||
BcMedia::Iframe(BcMediaIframe { microseconds, .. }) => Some(*microseconds),
|
||||
BcMedia::Pframe(BcMediaPframe { microseconds, .. }) => Some(*microseconds),
|
||||
_ => None,
|
||||
})
|
||||
.next()
|
||||
.map(|i| i as FrameTime);
|
||||
if let Some(last_frame) = last_frame {
|
||||
while match self.buf.front() {
|
||||
Some(BcMedia::Iframe(BcMediaIframe { microseconds, .. })) => {
|
||||
last_frame - *microseconds as FrameTime > BUFFER_TIME
|
||||
}
|
||||
}
|
||||
aac @ BcMedia::Aac(_) => {
|
||||
if let Some(last) = self.buf.back_mut().as_mut() {
|
||||
last.push(aac);
|
||||
Some(BcMedia::Pframe(BcMediaPframe { microseconds, .. })) => {
|
||||
last_frame - *microseconds as FrameTime > BUFFER_TIME
|
||||
}
|
||||
}
|
||||
adpcm @ BcMedia::Adpcm(_) => {
|
||||
if let Some(last) = self.buf.back_mut().as_mut() {
|
||||
last.push(adpcm);
|
||||
}
|
||||
}
|
||||
BcMedia::InfoV1(_) | BcMedia::InfoV2(_) => {}
|
||||
}
|
||||
if was_iframe {
|
||||
if let Some(last_frame_time) = self.last_iframe_time() {
|
||||
let mut time_delta = self
|
||||
.first_iframe_time()
|
||||
.map(|ff| last_frame_time.saturating_sub(ff));
|
||||
while let Some(time) = time_delta {
|
||||
if time > BUFFER_TIME && self.buf.len() > BUFFER_SIZE {
|
||||
let _ = self.buf.pop_front();
|
||||
debug!(
|
||||
"Popping frame with time difference of {:?}",
|
||||
Duration::from_micros(time.try_into().unwrap_or(0))
|
||||
);
|
||||
time_delta = self
|
||||
.first_iframe_time()
|
||||
.map(|ff| last_frame_time.saturating_sub(ff));
|
||||
} else {
|
||||
debug!("Iframes left in the buffer: {}", self.buf.len());
|
||||
break;
|
||||
}
|
||||
Some(_) => true,
|
||||
None => false,
|
||||
} && self.buf.len() > BUFFER_SIZE
|
||||
{
|
||||
if self.buf.pop_front().is_none() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn last_iframe_time(&self) -> Option<FrameTime> {
|
||||
self.buf
|
||||
.back()
|
||||
.as_ref()
|
||||
.and_then(|b| b.first())
|
||||
.and_then(|f| {
|
||||
if let BcMedia::Iframe(frame) = f {
|
||||
Some(frame.microseconds as FrameTime)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})
|
||||
}
|
||||
// fn last_iframe_time(&self) -> Option<FrameTime> {
|
||||
// let (fronts, backs) = self.buf.as_slices();
|
||||
// backs
|
||||
// .iter()
|
||||
// .rev()
|
||||
// .chain(&mut fronts.iter().rev())
|
||||
// .flat_map(|frame| match frame {
|
||||
// BcMedia::Iframe(BcMediaIframe { microseconds, .. }) => Some(*microseconds),
|
||||
// _ => None,
|
||||
// })
|
||||
// .next()
|
||||
// .map(|i| i as FrameTime)
|
||||
// }
|
||||
|
||||
fn first_iframe_time(&self) -> Option<FrameTime> {
|
||||
self.buf
|
||||
.front()
|
||||
.as_ref()
|
||||
.and_then(|b| b.first())
|
||||
.and_then(|f| {
|
||||
if let BcMedia::Iframe(frame) = f {
|
||||
Some(frame.microseconds as FrameTime)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})
|
||||
}
|
||||
// fn first_iframe_time(&self) -> Option<FrameTime> {
|
||||
// let (fronts, backs) = self.buf.as_slices();
|
||||
// fronts
|
||||
// .iter()
|
||||
// .chain(&mut backs.iter())
|
||||
// .flat_map(|frame| match frame {
|
||||
// BcMedia::Iframe(BcMediaIframe { microseconds, .. }) => Some(*microseconds),
|
||||
// _ => None,
|
||||
// })
|
||||
// .next()
|
||||
// .map(|i| i as FrameTime)
|
||||
// }
|
||||
|
||||
fn start_time(&self) -> Option<FrameTime> {
|
||||
if let Some(BcMedia::Iframe(data)) =
|
||||
self.buf.front().and_then(|inner_buf| inner_buf.first())
|
||||
{
|
||||
Some(data.microseconds as FrameTime)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
let (fronts, backs) = self.buf.as_slices();
|
||||
fronts
|
||||
.iter()
|
||||
.chain(&mut backs.iter())
|
||||
.flat_map(|frame| match frame {
|
||||
BcMedia::Iframe(BcMediaIframe { microseconds, .. }) => Some(*microseconds),
|
||||
BcMedia::Pframe(BcMediaPframe { microseconds, .. }) => Some(*microseconds),
|
||||
_ => None,
|
||||
})
|
||||
.next()
|
||||
.map(|i| i as FrameTime)
|
||||
}
|
||||
|
||||
fn end_time(&self) -> Option<FrameTime> {
|
||||
if let Some(innerbuffer) = self.buf.back() {
|
||||
innerbuffer
|
||||
.iter()
|
||||
.flat_map(|frame| match frame {
|
||||
BcMedia::Iframe(data) => Some(data.microseconds as FrameTime),
|
||||
BcMedia::Pframe(data) => Some(data.microseconds as FrameTime),
|
||||
_ => None,
|
||||
})
|
||||
.max()
|
||||
} else {
|
||||
None
|
||||
}
|
||||
let (fronts, backs) = self.buf.as_slices();
|
||||
backs
|
||||
.iter()
|
||||
.rev()
|
||||
.chain(&mut fronts.iter().rev())
|
||||
.flat_map(|frame| match frame {
|
||||
BcMedia::Iframe(BcMediaIframe { microseconds, .. }) => Some(*microseconds),
|
||||
BcMedia::Pframe(BcMediaPframe { microseconds, .. }) => Some(*microseconds),
|
||||
_ => None,
|
||||
})
|
||||
.next()
|
||||
.map(|i| i as FrameTime)
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) struct NeoMediaSenders {
|
||||
data_source: ReceiverStream<BcMedia>,
|
||||
data_source: ReceiverStream<FactoryCommand>,
|
||||
client_source: ReceiverStream<NeoMediaSender>,
|
||||
shared: Arc<NeoMediaShared>,
|
||||
uid: AtomicU64,
|
||||
@@ -160,7 +146,7 @@ pub(super) struct NeoMediaSenders {
|
||||
impl NeoMediaSenders {
|
||||
pub(super) fn new(
|
||||
shared: Arc<NeoMediaShared>,
|
||||
data_source: ReceiverStream<BcMedia>,
|
||||
data_source: ReceiverStream<FactoryCommand>,
|
||||
client_source: ReceiverStream<NeoMediaSender>,
|
||||
) -> Self {
|
||||
Self {
|
||||
@@ -317,16 +303,60 @@ impl NeoMediaSenders {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn clear_buffer(&mut self) -> AnyResult<()> {
|
||||
self.buffer.buf.clear();
|
||||
self.shared.buffer_ready.store(false, Ordering::Relaxed);
|
||||
for client in self.client_data.values_mut() {
|
||||
// Set them into the non init state
|
||||
// This will make them wait for the
|
||||
// buffer to be enough then jump to live
|
||||
client.inited = false;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn update_springs(&mut self) -> AnyResult<()> {
|
||||
for client in self.client_data.values_mut() {
|
||||
client.start_time.update().await;
|
||||
if let Some(new_target) = client
|
||||
.target_live_time(&self.buffer)
|
||||
.await?
|
||||
.map(|i| i as f64)
|
||||
{
|
||||
client.target_time.set_target(new_target);
|
||||
}
|
||||
client.target_time.update().await;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(super) async fn run(&mut self) -> AnyResult<()> {
|
||||
let mut interval = tokio::time::interval(Duration::from_millis(20)); // 50 FPS
|
||||
loop {
|
||||
tokio::task::yield_now().await;
|
||||
self.update_springs().await?;
|
||||
tokio::select! {
|
||||
_ = interval.tick() => {
|
||||
self.handle_buffer().await
|
||||
},
|
||||
Some(v) = self.data_source.next() => {
|
||||
self.handle_new_data(v).await
|
||||
match v {
|
||||
FactoryCommand::BcMedia(media) => {
|
||||
self.handle_new_data(media).await?;
|
||||
},
|
||||
FactoryCommand::ClearBuffer => {
|
||||
self.clear_buffer().await?;
|
||||
},
|
||||
FactoryCommand::JumpToLive => {
|
||||
for client in self.client_data.values_mut() {
|
||||
// Set them into the non init state
|
||||
// This will make them wait for the
|
||||
// buffer to be enough then jump to live
|
||||
client.inited = false;
|
||||
}
|
||||
},
|
||||
}
|
||||
Ok(())
|
||||
},
|
||||
Some(v) = self.client_source.next() => {
|
||||
self.handle_new_client(v).await
|
||||
@@ -346,11 +376,8 @@ pub(super) enum NeoMediaSenderCommand {
|
||||
}
|
||||
#[derive(Debug)]
|
||||
pub(super) struct NeoMediaSender {
|
||||
start_time: FrameTime,
|
||||
target_start_time: FrameTime,
|
||||
smoothed_start_time: f64,
|
||||
start_time_v: f64,
|
||||
start_time_update: Instant,
|
||||
start_time: Spring,
|
||||
target_time: Spring,
|
||||
last_sent_time: FrameTime,
|
||||
vid: Option<AppSrc>,
|
||||
aud: Option<AppSrc>,
|
||||
@@ -371,11 +398,8 @@ impl NeoMediaSender {
|
||||
pub(super) fn new() -> Self {
|
||||
let (tx, rx) = channel(30);
|
||||
Self {
|
||||
start_time: 0,
|
||||
target_start_time: 0,
|
||||
smoothed_start_time: 0.0,
|
||||
start_time_v: 0.0,
|
||||
start_time_update: Instant::now(),
|
||||
start_time: Spring::new(0.0, 0.0, 2.5),
|
||||
target_time: Spring::new(0.0, 0.0, 0.25),
|
||||
last_sent_time: 0,
|
||||
vid: None,
|
||||
aud: None,
|
||||
@@ -405,8 +429,12 @@ impl NeoMediaSender {
|
||||
let jump_method = JumpMethod::BufferPerunit(0.75);
|
||||
Ok(match jump_method {
|
||||
JumpMethod::MiddleIFrame => {
|
||||
let idx = frames.len().saturating_div(2);
|
||||
frames.get(idx).and_then(|f| f.first()).and_then(|f| {
|
||||
let iframes = frames
|
||||
.iter()
|
||||
.filter(|f| matches!(f, BcMedia::Iframe(_)))
|
||||
.collect::<Vec<_>>();
|
||||
let idx = iframes.len().saturating_div(2);
|
||||
iframes.get(idx).and_then(|f| {
|
||||
if let BcMedia::Iframe(data) = f {
|
||||
Some(data.microseconds as FrameTime)
|
||||
} else {
|
||||
@@ -426,23 +454,25 @@ impl NeoMediaSender {
|
||||
|
||||
async fn jump_to_live(&mut self, buffer: &NeoBuffer) -> AnyResult<()> {
|
||||
if self.inited {
|
||||
let runtime = self.get_runtime().unwrap_or(0);
|
||||
let target_time = self.target_live_time(buffer).await?;
|
||||
if let Some(target_time) = target_time {
|
||||
if let Some(new_target_time) = self.target_live_time(buffer).await? {
|
||||
self.target_time.reset_to(new_target_time as f64);
|
||||
|
||||
let runtime = self.get_runtime().unwrap_or(0);
|
||||
if let Some(et) = buffer.end_time() {
|
||||
if let Ok(delta) = TryInto::<u64>::try_into(et - target_time) {
|
||||
if let Ok(delta) = TryInto::<u64>::try_into(et - self.target_time.value_i64()) {
|
||||
debug!("Expected latency: {:?}", Duration::from_micros(delta));
|
||||
}
|
||||
}
|
||||
|
||||
self.start_time = target_time - runtime;
|
||||
self.target_start_time = self.start_time;
|
||||
self.smoothed_start_time = self.start_time as f64;
|
||||
self.start_time_v = 0.0;
|
||||
self.last_sent_time = target_time;
|
||||
self.start_time
|
||||
.reset_to(self.target_time.value() - (runtime as f64));
|
||||
self.last_sent_time = self.target_time.value_i64();
|
||||
debug!(
|
||||
"Target time: {:?}, New start time: {:?}, New Runtime: {:?}, Actual Runtime: {:?}",
|
||||
Duration::from_micros(target_time.try_into().unwrap_or(0)), Duration::from_micros(self.start_time.try_into().unwrap_or(0)), Duration::from_micros(self.buftime_to_runtime(target_time).try_into().unwrap_or(0)), Duration::from_micros(runtime.try_into().unwrap_or(0))
|
||||
Duration::from_micros(self.target_time.value_u64()),
|
||||
Duration::from_micros(self.start_time.value_u64()),
|
||||
Duration::from_micros(self.target_time.value_u64()),
|
||||
Duration::from_micros(runtime.try_into().unwrap_or(0))
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -451,39 +481,26 @@ impl NeoMediaSender {
|
||||
}
|
||||
|
||||
async fn stretch_live(&mut self, buffer: &NeoBuffer) -> AnyResult<()> {
|
||||
// Desired live time
|
||||
let target_time = self.target_live_time(buffer).await?;
|
||||
// Actual live time
|
||||
let actual_time = self.get_buftime();
|
||||
let st = buffer.start_time();
|
||||
let et = buffer.end_time();
|
||||
if let (Some(target_time), Some(actual_time), Some(st), Some(et)) =
|
||||
(target_time, actual_time, st, et)
|
||||
{
|
||||
if let (Some(actual_time), Some(st), Some(et)) = (actual_time, st, et) {
|
||||
if actual_time > st.saturating_sub(LATENCY * 2)
|
||||
&& actual_time < et.saturating_add(LATENCY * 2)
|
||||
{
|
||||
// Only do this while inside the buffer
|
||||
self.target_start_time = self.start_time + (target_time - actual_time); // Adjust
|
||||
self.start_time.set_target(
|
||||
self.start_time.value() + self.target_time.value() - (actual_time as f64),
|
||||
); // Adjust
|
||||
|
||||
// Now for the spring
|
||||
let dt = (Instant::now() - self.start_time_update)
|
||||
.min(Duration::from_millis(200))
|
||||
.as_secs_f64();
|
||||
spring_update(
|
||||
&mut self.smoothed_start_time,
|
||||
self.target_start_time as f64,
|
||||
&mut self.start_time_v,
|
||||
2.5,
|
||||
dt,
|
||||
);
|
||||
if let Some(new_actual_time) = self.get_buftime() {
|
||||
let expected_position = (new_actual_time - st) as f32 / (et - st) as f32;
|
||||
debug!("expected_position: {}", expected_position);
|
||||
}
|
||||
}
|
||||
}
|
||||
self.start_time_update = Instant::now();
|
||||
self.start_time.update().await;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -541,11 +558,11 @@ impl NeoMediaSender {
|
||||
}
|
||||
|
||||
fn runtime_to_buftime(&self, runtime: FrameTime) -> FrameTime {
|
||||
runtime.saturating_add(self.start_time)
|
||||
runtime.saturating_add(self.start_time.value_i64())
|
||||
}
|
||||
|
||||
fn buftime_to_runtime(&self, buftime: FrameTime) -> FrameTime {
|
||||
buftime.saturating_sub(self.start_time).max(0)
|
||||
buftime.saturating_sub(self.start_time.value_i64()).max(0)
|
||||
}
|
||||
|
||||
async fn process_buffer(&mut self, buf: &NeoBuffer) -> AnyResult<()> {
|
||||
@@ -581,47 +598,43 @@ impl NeoMediaSender {
|
||||
);
|
||||
}
|
||||
let mut last_sent_time = min_time;
|
||||
let mut found_start = false;
|
||||
let mut buf_it = buf.buf.iter().peekable();
|
||||
while let Some(frames) = buf_it.next() {
|
||||
tokio::task::yield_now().await;
|
||||
if !found_start {
|
||||
let next_frames = buf_it.peek();
|
||||
if let Some(BcMedia::Iframe(frame)) = next_frames.and_then(|b| b.first()) {
|
||||
// Get time of next IFrame
|
||||
// if it is after min_time, then the
|
||||
// start shuld happen between frames and next_frames
|
||||
if frame.microseconds as FrameTime > min_time {
|
||||
found_start = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut buf_it = buf.buf.iter();
|
||||
|
||||
if found_start {
|
||||
// We have found the start send eveythin until we get passed the
|
||||
// max time
|
||||
for frame in frames {
|
||||
let frame_time = match frame {
|
||||
BcMedia::Iframe(data) => data.microseconds as FrameTime,
|
||||
BcMedia::Pframe(data) => data.microseconds as FrameTime,
|
||||
_ => last_sent_time,
|
||||
};
|
||||
if frame_time > min_time && frame_time <= max_time {
|
||||
if let (Some(start_time), Some(end_time)) =
|
||||
(buf.start_time(), buf.end_time())
|
||||
{
|
||||
debug!(
|
||||
"Frame Run Position: {}",
|
||||
(frame_time - start_time) as f32 / (end_time - start_time) as f32
|
||||
);
|
||||
}
|
||||
self.send_buffer(frame).await?;
|
||||
last_sent_time = frame_time;
|
||||
} else if frame_time > max_time {
|
||||
return Ok(last_sent_time);
|
||||
}
|
||||
// Remove before start frame
|
||||
buf_it
|
||||
.take_while_ref(|f| match f {
|
||||
BcMedia::Iframe(BcMediaIframe { microseconds, .. }) => {
|
||||
*microseconds as FrameTime <= min_time
|
||||
}
|
||||
BcMedia::Pframe(BcMediaPframe { microseconds, .. }) => {
|
||||
*microseconds as FrameTime <= min_time
|
||||
}
|
||||
_ => true,
|
||||
})
|
||||
.for_each(drop);
|
||||
|
||||
// Send frames afterwards
|
||||
let frames_to_send = buf_it.take_while(|f| match f {
|
||||
BcMedia::Iframe(BcMediaIframe { microseconds, .. }) => {
|
||||
*microseconds as FrameTime <= max_time
|
||||
}
|
||||
BcMedia::Pframe(BcMediaPframe { microseconds, .. }) => {
|
||||
*microseconds as FrameTime <= max_time
|
||||
}
|
||||
_ => true,
|
||||
});
|
||||
|
||||
for frame in frames_to_send {
|
||||
match frame {
|
||||
BcMedia::Iframe(data) => {
|
||||
last_sent_time = data.microseconds as FrameTime;
|
||||
}
|
||||
BcMedia::Pframe(data) => {
|
||||
last_sent_time = data.microseconds as FrameTime;
|
||||
}
|
||||
_ => {}
|
||||
};
|
||||
self.send_buffer(frame).await?;
|
||||
}
|
||||
Ok(last_sent_time)
|
||||
}
|
||||
@@ -728,25 +741,3 @@ impl NeoMediaSender {
|
||||
Ok(true)
|
||||
}
|
||||
}
|
||||
|
||||
const EPS: f64 = 1e-5;
|
||||
fn halflife_to_damping(halflife: f64) -> f64 {
|
||||
(4.0 * std::f64::consts::LN_2) / (halflife + EPS)
|
||||
}
|
||||
|
||||
// fn damping_to_halflife(damping: f32) -> f32 {
|
||||
// (4.0f32 * std::f32::consts::LN_2) / (damping + EPS)
|
||||
// }
|
||||
fn fast_negexp(x: f64) -> f64 {
|
||||
1.0 / (1.0 + x + 0.48 * x * x + 0.235 * x * x * x)
|
||||
}
|
||||
|
||||
fn spring_update(value: &mut f64, target: f64, velocity: &mut f64, halflife: f64, dt: f64) {
|
||||
let y = halflife_to_damping(halflife) / 2.0;
|
||||
let j0 = *value - target;
|
||||
let j1 = *velocity + j0 * y;
|
||||
let eydt = fast_negexp(y * dt);
|
||||
|
||||
*value = eydt * (j0 + j1 * dt) + target;
|
||||
*velocity = eydt * (*velocity - j1 * y * dt);
|
||||
}
|
||||
+28
-3
@@ -16,7 +16,6 @@ use gstreamer_rtsp_server::{
|
||||
RTSPAuth, RTSPFilterResult, RTSPServer, RTSPToken, RTSP_TOKEN_MEDIA_FACTORY_ROLE,
|
||||
};
|
||||
use log::*;
|
||||
use neolink_core::bcmedia::model::*;
|
||||
use std::{
|
||||
collections::{hash_map::Entry, HashMap, HashSet},
|
||||
fs,
|
||||
@@ -46,7 +45,10 @@ impl NeoRtspServer {
|
||||
Ok(factory)
|
||||
}
|
||||
|
||||
pub(crate) async fn get_sender<T: Into<String>>(&self, tag: T) -> Option<Sender<BcMedia>> {
|
||||
pub(crate) async fn get_sender<T: Into<String>>(
|
||||
&self,
|
||||
tag: T,
|
||||
) -> Option<Sender<FactoryCommand>> {
|
||||
self.imp().get_sender(tag).await
|
||||
}
|
||||
|
||||
@@ -216,6 +218,26 @@ impl NeoRtspServer {
|
||||
}
|
||||
}));
|
||||
}
|
||||
|
||||
// Clear buffers on all senders of a tag
|
||||
pub(crate) async fn clear_buffer<T: Into<String>>(&self, tag: T) -> AnyResult<()> {
|
||||
if let Some(sender) = self.imp().get_sender(tag).await {
|
||||
sender.send(FactoryCommand::ClearBuffer).await?;
|
||||
Ok(())
|
||||
} else {
|
||||
Err(anyhow!("No such tag"))
|
||||
}
|
||||
}
|
||||
|
||||
// Jump to live on all senders of a tag
|
||||
pub(crate) async fn jump_to_live<T: Into<String>>(&self, tag: T) -> AnyResult<()> {
|
||||
if let Some(sender) = self.imp().get_sender(tag).await {
|
||||
sender.send(FactoryCommand::JumpToLive).await?;
|
||||
Ok(())
|
||||
} else {
|
||||
Err(anyhow!("No such tag"))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
unsafe impl Send for NeoRtspServer {}
|
||||
@@ -264,7 +286,10 @@ impl NeoRtspServerImpl {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(crate) async fn get_sender<T: Into<String>>(&self, tag: T) -> Option<Sender<BcMedia>> {
|
||||
pub(crate) async fn get_sender<T: Into<String>>(
|
||||
&self,
|
||||
tag: T,
|
||||
) -> Option<Sender<FactoryCommand>> {
|
||||
let key = tag.into();
|
||||
self.medias
|
||||
.read()
|
||||
|
||||
+37
-16
@@ -61,11 +61,13 @@ use tokio_stream::StreamExt;
|
||||
|
||||
mod cmdline;
|
||||
mod gst;
|
||||
mod spring;
|
||||
mod states;
|
||||
|
||||
use super::config::Config;
|
||||
pub(crate) use cmdline::Opt;
|
||||
use gst::NeoRtspServer;
|
||||
pub(crate) use spring::*;
|
||||
use states::*;
|
||||
|
||||
/// Entry point for the rtsp subcommand
|
||||
@@ -182,7 +184,7 @@ async fn camera_main(camera: Camera<Disconnected>) -> Result<(), CameraFailureKi
|
||||
let tags = loggedin.shared.get_tags();
|
||||
let rtsp_thread = loggedin.get_rtsp();
|
||||
|
||||
// Check if buffers are already perpared (from say previous connection)
|
||||
// Check if buffers were prepared before we clear
|
||||
let buffers_prepared = tags
|
||||
.iter()
|
||||
.map(|tag| rtsp_thread.buffer_ready(tag))
|
||||
@@ -191,6 +193,13 @@ async fn camera_main(camera: Camera<Disconnected>) -> Result<(), CameraFailureKi
|
||||
.all(|a| a)
|
||||
.await;
|
||||
|
||||
// Clear all buffers present
|
||||
tags.iter()
|
||||
.map(|tag| rtsp_thread.clear_buffer(tag))
|
||||
.collect::<FuturesUnordered<_>>()
|
||||
.collect::<Vec<_>>()
|
||||
.await;
|
||||
|
||||
// Start pulling data from the camera
|
||||
let mut streaming = loggedin
|
||||
.stream()
|
||||
@@ -198,22 +207,28 @@ async fn camera_main(camera: Camera<Disconnected>) -> Result<(), CameraFailureKi
|
||||
.with_context(|| format!("{}: Could not start stream", name))
|
||||
.map_err(CameraFailureKind::Retry)?;
|
||||
|
||||
if !buffers_prepared {
|
||||
// Wait for buffers to be prepared
|
||||
let mut waiter = tokio::time::interval(Duration::from_micros(500));
|
||||
loop {
|
||||
waiter.tick().await;
|
||||
if tags
|
||||
.iter()
|
||||
.map(|tag| rtsp_thread.buffer_ready(tag))
|
||||
.collect::<FuturesUnordered<_>>()
|
||||
.all(|f| f.unwrap_or(false))
|
||||
.await
|
||||
{
|
||||
break;
|
||||
}
|
||||
// Wait for buffers to be prepared
|
||||
let mut waiter = tokio::time::interval(Duration::from_micros(500));
|
||||
loop {
|
||||
waiter.tick().await;
|
||||
if tags
|
||||
.iter()
|
||||
.map(|tag| rtsp_thread.buffer_ready(tag))
|
||||
.collect::<FuturesUnordered<_>>()
|
||||
.all(|f| f.unwrap_or(false))
|
||||
.await
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
tags.iter()
|
||||
.map(|tag| rtsp_thread.jump_to_live(tag))
|
||||
.collect::<FuturesUnordered<_>>()
|
||||
.collect::<Vec<_>>()
|
||||
.await;
|
||||
|
||||
if !buffers_prepared {
|
||||
// Clear all current media and force a reconnect
|
||||
// This shoudld stop them from watching the "Stream Not Ready Thing"
|
||||
tags.iter()
|
||||
@@ -221,8 +236,8 @@ async fn camera_main(camera: Camera<Disconnected>) -> Result<(), CameraFailureKi
|
||||
.collect::<FuturesUnordered<_>>()
|
||||
.collect::<Vec<_>>()
|
||||
.await;
|
||||
log::info!("{}: Buffers prepared", name);
|
||||
}
|
||||
log::info!("{}: Buffers prepared", name);
|
||||
|
||||
loop {
|
||||
// Wait for error or reason to pause
|
||||
@@ -302,6 +317,12 @@ async fn camera_main(camera: Camera<Disconnected>) -> Result<(), CameraFailureKi
|
||||
.with_context(|| format!("{}: Error while paused", name))
|
||||
.map_err(CameraFailureKind::Retry)?;
|
||||
|
||||
tags.iter()
|
||||
.map(|tag| rtsp_thread.jump_to_live(tag))
|
||||
.collect::<FuturesUnordered<_>>()
|
||||
.collect::<Vec<_>>()
|
||||
.await;
|
||||
|
||||
streaming = paused
|
||||
.stream()
|
||||
.await
|
||||
|
||||
@@ -0,0 +1,88 @@
|
||||
//! A critically damped spring
|
||||
use tokio::time::Instant;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub(crate) struct Spring {
|
||||
last_update: Instant,
|
||||
target: f64,
|
||||
value: f64,
|
||||
velocity: f64,
|
||||
halflife: f64,
|
||||
}
|
||||
|
||||
impl Spring {
|
||||
pub(crate) fn new(value: f64, target: f64, halflife: f64) -> Self {
|
||||
Self {
|
||||
value,
|
||||
target,
|
||||
halflife,
|
||||
last_update: Instant::now(),
|
||||
velocity: 0.0f64,
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) async fn update(&mut self) {
|
||||
let now = Instant::now();
|
||||
let dt = now - self.last_update;
|
||||
self.last_update = now;
|
||||
spring_update(
|
||||
&mut self.value,
|
||||
self.target,
|
||||
&mut self.velocity,
|
||||
self.halflife,
|
||||
dt.as_secs_f64(),
|
||||
);
|
||||
}
|
||||
|
||||
pub(crate) fn value(&self) -> f64 {
|
||||
self.value
|
||||
}
|
||||
|
||||
// pub(crate) fn value_u32(&self) -> u32 {
|
||||
// self.value.max(std::u32::MIN as f64).floor().min(std::u32::MAX as f64) as u32
|
||||
// }
|
||||
pub(crate) fn value_i64(&self) -> i64 {
|
||||
self.value
|
||||
.max(std::i64::MIN as f64)
|
||||
.floor()
|
||||
.min(std::i64::MAX as f64) as i64
|
||||
}
|
||||
pub(crate) fn value_u64(&self) -> u64 {
|
||||
self.value
|
||||
.max(std::u64::MIN as f64)
|
||||
.floor()
|
||||
.min(std::u64::MAX as f64) as u64
|
||||
}
|
||||
|
||||
pub(crate) fn set_target(&mut self, target: f64) {
|
||||
self.target = target;
|
||||
}
|
||||
|
||||
pub(crate) fn reset_to(&mut self, target: f64) {
|
||||
self.target = target;
|
||||
self.value = target;
|
||||
self.velocity = 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
const EPS: f64 = 1e-5;
|
||||
fn halflife_to_damping(halflife: f64) -> f64 {
|
||||
(4.0 * std::f64::consts::LN_2) / (halflife + EPS)
|
||||
}
|
||||
|
||||
// fn damping_to_halflife(damping: f32) -> f32 {
|
||||
// (4.0f32 * std::f32::consts::LN_2) / (damping + EPS)
|
||||
// }
|
||||
fn fast_negexp(x: f64) -> f64 {
|
||||
1.0 / (1.0 + x + 0.48 * x * x + 0.235 * x * x * x)
|
||||
}
|
||||
|
||||
fn spring_update(value: &mut f64, target: f64, velocity: &mut f64, halflife: f64, dt: f64) {
|
||||
let y = halflife_to_damping(halflife) / 2.0;
|
||||
let j0 = *value - target;
|
||||
let j1 = *velocity + j0 * y;
|
||||
let eydt = fast_negexp(y * dt);
|
||||
|
||||
*value = eydt * (j0 + j1 * dt) + target;
|
||||
*velocity = eydt * (*velocity - j1 * y * dt);
|
||||
}
|
||||
@@ -11,6 +11,7 @@ use tokio::{sync::RwLock, task::JoinSet};
|
||||
use neolink_core::bc_protocol::{BcCamera, StreamKind as Stream};
|
||||
|
||||
use super::{camera::Camera, LoggedIn};
|
||||
use crate::rtsp::gst::FactoryCommand;
|
||||
|
||||
pub(crate) struct Streaming {
|
||||
pub(crate) camera: BcCamera,
|
||||
@@ -68,9 +69,12 @@ impl Camera<Streaming> {
|
||||
Err(_) => trace!(" - Error"),
|
||||
}
|
||||
// debug!("Straming: Send");
|
||||
timeout(Duration::from_secs(15), sender.send(data?))
|
||||
.await
|
||||
.with_context(|| "Timed out waiting to send Media Frame")??;
|
||||
timeout(
|
||||
Duration::from_secs(15),
|
||||
sender.send(FactoryCommand::BcMedia(data?)),
|
||||
)
|
||||
.await
|
||||
.with_context(|| "Timed out waiting to send Media Frame")??;
|
||||
// debug!("Straming: Sent");
|
||||
}
|
||||
});
|
||||
|
||||
Reference in new issue
Block a user