Switch too non-locking, fail skipping, signal reading

This commit is contained in:
QuantumEntangledAndy committed 2023-04-17 19:45:54 +07:00
1 parent 5e9783fed3
commit f8b48544f8
16 files changed
+220 -93

No files matched your search

Generated
+1
View File
@@ -209,6 +209,7 @@ dependencies = [
"anstyle",
"bitflags",
"clap_lex",
"once_cell",
"strsim",
]
+1 -1
View File
@@ -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"
+5
View File
@@ -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 {
+14
View File
@@ -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))
+1 -1
View File
@@ -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 {
+11 -10
View File
@@ -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 -3
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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(())
}
}
+4
View File
@@ -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
View File
@@ -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;
+11 -11
View File
@@ -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");
}
});
}