Try not to implement stream

This commit is contained in:
QuantumEntangledAndy committed 2023-09-20 12:37:44 +07:00
1 parent e41668df53
commit 23524c6422
4 files changed
+34 -86

No files matched your search

+22 -63
View File
@@ -1,14 +1,14 @@
use super::BcConnection;
use crate::bcmedia::codex::BcMediaCodex;
use crate::{bc::model::*, Error, Result};
use futures::stream::{IntoAsyncRead, Stream, StreamExt, TryStreamExt};
use crate::{bc::model::*, bcmedia::model::*, Error, Result};
use futures::stream::{Stream, TryStreamExt};
use std::io::{Error as IoError, ErrorKind, Result as IoResult};
use std::pin::Pin;
use std::task::{Context, Poll};
use tokio::sync::mpsc::Receiver;
use tokio_stream::wrappers::ReceiverStream;
use tokio_stream::{wrappers::ReceiverStream, StreamExt};
use tokio_util::codec::FramedRead;
use tokio_util::compat::{Compat, FuturesAsyncReadCompatExt};
use tokio_util::compat::FuturesAsyncReadCompatExt;
pub struct BcSubscription<'a> {
rx: ReceiverStream<Result<Bc>>,
@@ -35,57 +35,6 @@ impl<'a> Stream for BcStream<'a> {
}
}
pub struct BcPayloadStream<'a> {
rx: &'a mut ReceiverStream<Result<Bc>>,
}
impl<'a> Unpin for BcPayloadStream<'a> {}
impl<'a> Stream for BcPayloadStream<'a> {
type Item = IoResult<Vec<u8>>;
fn poll_next(
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:
BcBody::ModernMsg(ModernMsg {
payload: Some(BcPayloads::Binary(data)),
..
}),
..
}))) => {
// 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))) => {
// 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;
}
}
// log::debug!("PayloadStream: Default Pend and Wake");
cx.waker().wake_by_ref();
Poll::Pending
}
}
pub type BcMediaStream<'b> = FramedRead<Compat<IntoAsyncRead<BcPayloadStream<'b>>>, BcMediaCodex>;
impl<'a> BcSubscription<'a> {
pub fn new(
rx: Receiver<Result<Bc>>,
@@ -127,16 +76,26 @@ impl<'a> BcSubscription<'a> {
BcStream { rx: &mut self.rx }
}
#[allow(unused)]
pub fn payload_stream(&'_ mut self) -> BcPayloadStream<'_> {
BcPayloadStream { rx: &mut self.rx }
pub fn payload_stream(&'_ mut self) -> impl Stream<Item = IoResult<Vec<u8>>> + '_ {
(&mut self.rx).filter_map(|x| match x {
Ok(Bc {
body:
BcBody::ModernMsg(ModernMsg {
payload: Some(BcPayloads::Binary(data)),
..
}),
..
}) => {
// log::debug!("PayloadStream: Data");
Some(Ok(data))
}
Ok(_) => None,
Err(e) => Some(Err(IoError::new(ErrorKind::Other, e))),
})
}
#[allow(unused)]
pub fn bcmedia_stream(&'_ mut self, strict: bool) -> BcMediaStream<'_> {
let async_read = BcPayloadStream { rx: &mut self.rx }
.into_async_read()
.compat();
pub fn bcmedia_stream(&'_ mut self, strict: bool) -> impl Stream<Item = Result<BcMedia>> + '_ {
let async_read = self.payload_stream().into_async_read().compat();
FramedRead::new(async_read, BcMediaCodex::new(strict))
}
}
-1
View File
@@ -137,7 +137,6 @@ impl BcCamera {
let channel_id = self.channel_id;
let handle = task::spawn(async move {
tokio::task::yield_now().await;
let mut sub_video = connection.subscribe(MSG_ID_VIDEO, msg_num).await?;
// On an E1 and swann cameras:
+2 -2
View File
@@ -532,6 +532,7 @@ impl StreamData {
AnyResult::Ok(())
},
v = async {
watchdog_rx.recv().await; // Wait forever for the first feed
loop {
let check_timeout = timeout(Duration::from_secs(3), watchdog_rx.recv()).await;
if let Err(_)| Ok(None) = check_timeout {
@@ -552,13 +553,12 @@ impl StreamData {
log::debug!("Running Stream Instance Task");
Box::pin(async move {
let res = async {
watchdog_tx.send(()).await?; // Feed the watchdog
let mut prev_ts = Duration::ZERO;
let mut stream_data = camera.start_video(name, 0, strict).await?;
watchdog_tx.send(()).await?; // Feed the watchdog
loop {
watchdog_tx.send(()).await?; // Feed the watchdog
let data = stream_data.get_data().await??;
watchdog_tx.send(()).await?; // Feed the watchdog
// Update the stream config with any information
match &data {
+10 -20
View File
@@ -1141,7 +1141,7 @@ fn build_h264(bin: &Element) -> Result<AppSrc> {
.dynamic_cast::<AppSrc>()
.map_err(|_| anyhow!("Cannot cast to appsrc."))?;
source.set_is_live(true);
source.set_is_live(false);
source.set_block(false);
source.set_property("emit-signals", false);
source.set_max_bytes(50000000u64); // 50MB
@@ -1153,11 +1153,9 @@ fn build_h264(bin: &Element) -> Result<AppSrc> {
.map_err(|_| anyhow!("Cannot cast back"))?;
let queue = make_queue("source_queue")?;
let parser = make_element("h264parse", "parser")?;
let payload = make_element("rtph264pay", "vid_pay")?;
let jitter = make_element("rtpjitterbuffer", "pay0")?;
jitter.set_property("latency", 2000u32);
bin.add_many(&[&source, &queue, &parser, &payload, &jitter])?;
Element::link_many(&[&source, &queue, &parser, &payload, &jitter])?;
let payload = make_element("rtph264pay", "pay0")?;
bin.add_many(&[&source, &queue, &parser, &payload])?;
Element::link_many(&[&source, &queue, &parser, &payload])?;
let source = source
.dynamic_cast::<AppSrc>()
@@ -1226,16 +1224,10 @@ fn build_aac(bin: &Element) -> Result<AppSrc> {
Err(_) => make_element("avdec_aac", "auddecoder_avdec_aac"),
}?;
let encoder = make_element("audioconvert", "audencoder")?;
let payload = make_element("rtpL16pay", "aud_pay")?;
let jitter = make_element("rtpjitterbuffer", "pay1")?;
jitter.set_property("latency", 2000u32);
let payload = make_element("rtpL16pay", "pay1")?;
bin.add_many(&[
&source, &queue, &parser, &decoder, &encoder, &payload, &jitter,
])?;
Element::link_many(&[
&source, &queue, &parser, &decoder, &encoder, &payload, &jitter,
])?;
bin.add_many(&[&source, &queue, &parser, &decoder, &encoder, &payload])?;
Element::link_many(&[&source, &queue, &parser, &decoder, &encoder, &payload])?;
let source = source
.dynamic_cast::<AppSrc>()
@@ -1282,13 +1274,11 @@ fn build_adpcm(bin: &Element, block_size: u32) -> Result<AppSrc> {
let queue = make_queue("audqueue")?;
let decoder = make_element("decodebin", "auddecoder")?;
let encoder = make_element("audioconvert", "audencoder")?;
let payload = make_element("rtpL16pay", "aud_pay")?;
let jitter = make_element("rtpjitterbuffer", "pay1")?;
jitter.set_property("latency", 2000u32);
let payload = make_element("rtpL16pay", "pay1")?;
bin.add_many(&[&source, &queue, &decoder, &encoder, &payload, &jitter])?;
bin.add_many(&[&source, &queue, &decoder, &encoder, &payload])?;
Element::link_many(&[&source, &queue, &decoder])?;
Element::link_many(&[&encoder, &payload, &jitter])?;
Element::link_many(&[&encoder, &payload])?;
decoder.connect_pad_added(move |_element, pad| {
debug!("Linking encoder to decoder: {:?}", pad.caps());
let sink_pad = encoder