Switch too non-locking, fail skipping, signal reading
This commit is contained in:
16 files changed
+220
-93
No files matched your search
Generated
+1
@@ -209,6 +209,7 @@ dependencies = [
|
||||
"anstyle",
|
||||
"bitflags",
|
||||
"clap_lex",
|
||||
"once_cell",
|
||||
"strsim",
|
||||
]
|
||||
|
||||
|
||||
+1
-1
@@ -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"
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
@@ -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<dyn Stream<Item = Result<Bc>> + Send + Sync +
|
||||
///
|
||||
/// There can be only one subscriber per kind of message at a time.
|
||||
pub struct BcConnection {
|
||||
sink: Arc<Mutex<BcConnSink>>,
|
||||
sink: Sender<Result<Bc>>,
|
||||
subscribers: Arc<Subscriber>,
|
||||
#[allow(dead_code)] // Not dead we just need to hold a reference to keep it alive
|
||||
rx_thread: RwLock<JoinSet<Result<()>>>,
|
||||
}
|
||||
|
||||
impl BcConnection {
|
||||
pub async fn new(sink: BcConnSink, mut source: BcConnSource) -> Result<BcConnection> {
|
||||
pub async fn new(mut sink: BcConnSink, mut source: BcConnSource) -> Result<BcConnection> {
|
||||
let subscribers: Arc<Subscriber> = Default::default();
|
||||
let sink = Arc::new(Mutex::new(sink));
|
||||
|
||||
let subs = subscribers.clone();
|
||||
|
||||
let (sinker, sinker_rx) = channel::<Result<Bc>>(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<Bc>,
|
||||
subscribers: &Subscriber,
|
||||
sink: &Mutex<BcConnSink>,
|
||||
sink: &Sender<Result<Bc>>,
|
||||
) -> 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)) => {
|
||||
|
||||
@@ -48,6 +48,7 @@ impl<'a> Stream for BcPayloadStream<'a> {
|
||||
mut self: Pin<&mut Self>,
|
||||
cx: &mut Context<'_>,
|
||||
) -> Poll<Option<IoResult<Vec<u8>>>> {
|
||||
// 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
|
||||
}
|
||||
|
||||
@@ -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<BcUdpCodex, Arc<UdpSocket>>;
|
||||
pub(crate) struct Discoverer {
|
||||
socket: Arc<UdpSocket>,
|
||||
handle: RwLock<JoinSet<()>>,
|
||||
writer: Mutex<SplitSink<ArcFramedSocket, (BcUdp, SocketAddr)>>,
|
||||
writer: Sender<Result<(BcUdp, SocketAddr)>>,
|
||||
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 {
|
||||
|
||||
@@ -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<tokio::time::error::Elapsed>),
|
||||
@@ -194,6 +202,12 @@ impl From<std::io::Error> for Error {
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> From<tokio::sync::mpsc::error::SendError<T>> for Error {
|
||||
fn from(_: tokio::sync::mpsc::error::SendError<T>) -> Self {
|
||||
Error::TokioBcSendError
|
||||
}
|
||||
}
|
||||
|
||||
impl From<cookie_factory::GenError> for Error {
|
||||
fn from(k: cookie_factory::GenError) -> Self {
|
||||
Error::GenError(std::sync::Arc::new(k))
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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(())
|
||||
});
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
+2
-2
@@ -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<PathBuf>,
|
||||
|
||||
+50
-2
@@ -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::<Bin>()
|
||||
.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")?;
|
||||
|
||||
+70
-42
@@ -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<bool> {
|
||||
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(())
|
||||
}
|
||||
}
|
||||
@@ -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<AppSrc>,
|
||||
pub(super) start_time: u64,
|
||||
pub(super) inited: bool,
|
||||
pub(super) clock: Option<Clock>,
|
||||
pub(super) enough_data: Arc<AtomicBool>,
|
||||
}
|
||||
+7
-1
@@ -162,7 +162,13 @@ async fn camera_main(camera: Camera<Disconnected>) -> 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::<neolink_core::Error>().unwrap();
|
||||
match e_inner {
|
||||
neolink_core::Error::CameraLoginFail => CameraFailureKind::Fatal(e),
|
||||
_ => CameraFailureKind::Retry(e),
|
||||
}
|
||||
})?;
|
||||
|
||||
let _ = loggedin.manage().await;
|
||||
|
||||
|
||||
@@ -52,21 +52,21 @@ impl Camera<Streaming> {
|
||||
.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");
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user